Claude Code is powerful out of the box. But the difference between a generic Claude Code session and one that understands your specific project, including its conventions, its pipeline, its agents, and its enforcement rules, is enormous. That gap is the problem Armature solves.
The Setup Tax
Every developer who has tried to get Claude Code working well on a real project has encountered the same friction: Claude Code knows how to write code, but it doesn’t know your code. It doesn’t know that your project uses pnpm not npm, that functions are capped at 50 lines by team convention, that PRs require a specific commit message format, or that you have a custom security agent that should run before merges.
You can teach it all of this, but that means writing a CLAUDE.md file, configuring agent definitions, wiring up MCP servers, creating git hooks, specifying permissions in settings.json, and documenting workflows. For a production team, that’s days of work, and it has to be done correctly, or you end up with an AI assistant that drifts, invents conventions, or ignores the ones you’ve established.
Armature eliminates that setup tax. It interviews you about your project, designs an architecture, and then assembles a complete, customized Claude Code development environment, ready to use.
What Armature Is
Armature is a meta-framework: a web application that generates customized Claude Code development environments for software projects. You bring your project idea; Armature produces a .claude/ directory (plus supporting files) that turns Claude Code into a specialized development partner for that project.
The output is not a starter template. It is a fully assembled environment with agents that know your stack, skills that match your workflow, git hooks that enforce your conventions, and documentation that reflects your architecture, all generated deterministically from your inputs.
Armature itself runs as a local web app with a Python/FastAPI backend and a Next.js frontend. It uses the Claude API (Anthropic SDK) for its own AI pipeline. SQLite handles persistence. No cloud account required, no data leaves your machine.
The Four-Stage Pipeline
At the core of Armature is a four-stage pipeline that transforms a project description into a generated environment:
Interviewer → Architect → Planner → GeneratorStage 1: Interviewer
The Interviewer agent conducts a structured conversational interview across seven steps:
- Project Overview, name, description, type classification
- Tech Stack, languages, frameworks, libraries, infrastructure
- Features, feature list with priorities
- Requirements, performance, team size, deployment targets
- Workflow, development process preferences
- PM Environment, project management tool integration (GitHub, Jira, Linear)
- Confirmation, review before handoff
The agent uses Claude’s tool-calling to incrementally extract a structured ProjectSpec as the conversation unfolds. Each step gates the next, the agent won’t proceed to architecture until the spec is solid.
Stage 2: Architect
The Architect agent designs the project’s technical architecture from the spec, working through seven structured steps:
- Step 0: Analysis & Structure, directory layout and high-level summary
- Step 1: Module Design, logical modules and their responsibilities
- Step 2: Database Design (conditional), schema, tables, and relationships, skipped for projects without a database
- Step 3: File Planning, individual files with paths and purposes
- Step 4: Dependency Requirements, external package requirements
- Step 5: Implementation Phases, incremental build sequence
- Step 6: Validation & Confirmation, consistency check and user sign-off
Each step is gated and auto-advances when the required fields are populated. The agent waits for explicit user confirmation at the final step before handing off.
The output is an ArchitectureSpec, a structured representation of the project’s layout, modules, dependencies, and delivery phases. This spec drives what gets generated in the final stage.
Stage 3: Planner (Optional)
The Planner agent creates a detailed project roadmap: epics, stories with acceptance criteria, story points, and milestones. The output is both a machine-readable project-plan.json (suitable for import into GitHub, Jira, or Linear) and a human-readable docs/roadmap.md.
Stage 4: Generator
The Generator runs the DeterministicAssembler, a single-pass engine that takes the project spec and architecture, selects the appropriate stack templates from the knowledge base, fills in all template variables, and produces a complete file tree. No LLM interaction is required for the core assembly; the output is deterministic given the same inputs.
What You Get
The generated environment is approximately 60 to 80 files. Here is the shape of a typical TypeScript/Next.js output:
my-saas-app/
│
├── CLAUDE.md # Master instruction file
├── .mcp.json # MCP server configuration
├── README.md
├── CONTRIBUTING.md
│
├── .claude/
│ ├── settings.json # Permissions and feature flags
│ ├── BOOTSTRAP.md # Post-generation setup guide
│ │
│ ├── agents/ # 12 specialized agent definitions
│ │ ├── architect.md
│ │ ├── coding.md
│ │ ├── reviewer.md
│ │ ├── security.md
│ │ ├── debugger.md
│ │ ├── api-reviewer.md
│ │ ├── accessibility-checker.md
│ │ ├── performance-reviewer.md
│ │ └── ...
│ │
│ ├── skills/ # 23+ slash command definitions
│ │ ├── implement/ # Full dev pipeline orchestration
│ │ ├── team/ # Parallel analysis teams
│ │ ├── security-audit/
│ │ ├── dependency-scan/
│ │ ├── docs/
│ │ └── ...
│ │
│ ├── teams/ # Agent Teams coordination templates
│ │ ├── implementation-team.yaml
│ │ ├── review-team.yaml
│ │ ├── security-team.yaml
│ │ └── ...
│ │
│ └── docs/ # Reference documentation
│ ├── getting-started.md
│ ├── coding-reference.md
│ ├── code-review-taxonomy.md
│ └── ...
│
├── .githooks/ # Enforcing git hooks
│ ├── pre-commit # Lint + secret detection
│ ├── commit-msg # Commit format enforcement
│ └── pre-push # Branch protection + tests
│
├── .github/
│ └── pull_request_template.md
│
├── docs/
│ ├── architecture.md # Generated from your architecture spec
│ └── roadmap.md
│
└── package.json, tsconfig.json, .eslintrc.json, jest.config.ts, ...The CLAUDE.md at the root is the master instruction file Claude Code reads on every session start. It contains your project’s conventions, commands, architecture overview, and workflow, all filled in with your actual project details. For a FastAPI backend with PostgreSQL, that means pytest, ruff, and mypy commands. For a SwiftUI macOS app, that means xcodebuild and swiftlint.
Agents Built for Your Stack
The 12 agent templates in the knowledge base, including architect, auditor, builder, coding, reviewer, debugger, security, security-auditor, performance-reviewer, accessibility-checker, api-reviewer, and ui-frontend-engineer, are compiled to stack-specific definitions with the right commands and conventions for your project.
The validator agent for a Python project runs pytest, ruff check, and mypy. The same agent for a Go project runs go test ./..., golangci-lint run, and go vet. These are not generic placeholders; they are the actual commands, populated from your tech stack.
Skills as Slash Commands
Generated environments ship with 23 skill directories out of the box, covering git workflows, testing standards, security scanning, documentation generation, and refactoring patterns. Each skill is a directory of markdown files defining a /command available in Claude Code.
The /implement pipeline is the most significant: it drives a full development lifecycle from reading a GitHub issue to merging a PR, using a two-agent model: Builder and Reviewer. The Builder handles five phases (plan, implement, validate, document, and ship) then hands off to the Reviewer for code review before merge.
/implement #123
Builder (plan → implement → validate → document → ship) → Reviewer → MergeSecurity Out of the Box
Security is not an add-on. Every generated environment includes a dedicated security agent, a security-auditor agent, and security skills including /security-audit, /check (with subcommands like /check compliance), and /dependency-scan. The security system covers OWASP Top 10 and supports compliance frameworks including SOC2, GDPR, HIPAA, and PCI-DSS. Git hooks detect secrets before commits.
Git Hooks and Enforcement
Three git hooks ship with every generated environment:
| Hook | What It Enforces |
|---|---|
pre-commit | Lint checks, secret detection |
commit-msg | Conventional commit format (type(scope): description) |
pre-push | Branch protection (blocks direct pushes to main), test suite |
Enforcement levels are configurable at generation time: Strict (all gates blocking), Standard (balanced), or Minimal (maximum flexibility).
Multiple Entry Points
Not every project starts from scratch, and not every team wants to go through a full interview. Armature offers four ways to generate an environment:
Interview (default): The full seven-step conversational interview. Best for new projects or when you want Armature to help you think through the architecture.
Quick Start Templates: 23 pre-built templates across seven categories, web, backend, desktop, mobile, CLI, data, and fullstack, covering Python, JavaScript/TypeScript, Swift, Rust, Go, Java, Ruby, PHP, Dart/Flutter, Kotlin, C#/.NET, and Svelte. Select a template, fill in your project name, and generate immediately.
PRD Upload: Upload a Product Requirements Document and Armature uses it to pre-fill the interview. Skips the early discovery stages; the conversation starts from a populated baseline.
Direct Import: If you already have a ProjectSpec or ArchitectureSpec as JSON, you can import it directly and skip to generation.
Tech Stack Coverage
The 23 quick-start templates span a wide surface area:
| Category | Templates |
|---|---|
| Web | Next.js, React SPA (Vite), Vue/Nuxt, SvelteKit, Rails, Laravel |
| Backend | FastAPI, Django, Express, Go API, NestJS, Spring Boot, .NET API |
| Desktop | SwiftUI macOS |
| Mobile | React Native (Expo), Flutter, Swift/iOS, Kotlin/Android |
| CLI | Python CLI, Go CLI, Rust CLI, Node.js CLI |
| Data | Python Data Science |
| Fullstack | Django Web Application |
Under the hood, the assembler detects stack signals from your tech choices and selects the appropriate template layer. TypeScript, Python, and Go projects get dedicated stack layers with specialized agents, scaffold files, and coding references. Other stacks (Rust, Java, Swift, Kotlin, etc.) use the generic layer with framework-appropriate scaffold and customization guidance.
Upgrade Existing Environments
If you already have a Claude Code environment, whether generated by an earlier Armature session or assembled by hand, the Upgrade system can bring it up to date. The six-step wizard audits your current environment, scores gaps against the current template library, generates file-level diffs, and applies changes with rollback support.
Getting Started
Armature runs locally. You need Python 3.11+, Node.js, and an Anthropic API key.
# Clone and install
git clone https://github.com/your-org/armature
cd armature
# Backend setup
cd backend
pip install -e .
cp .env.example .env
# Add your ANTHROPIC_API_KEY to .env
# Start the backend
uvicorn src.main:app --reload
# API running on http://localhost:8000
# Frontend setup (separate terminal)
cd frontend
npm install
npm run dev
# UI running on http://localhost:3000Open http://localhost:3000 and you’ll see the Interview page. Describe your project, for example, “a FastAPI REST API with PostgreSQL for a multi-tenant SaaS application”, and the Interviewer will guide you through the rest.
Alternatively, go to /quickstart, pick a template (say, “FastAPI” or “Next.js”), fill in your project name and description, and skip straight to generation.
Once generated, download the .zip, extract it into your project directory, and run ./init.sh to install dependencies and git hooks. Then open Claude Code in that directory. Claude Code will read CLAUDE.md on the first message and begin operating within your project’s conventions.
Why This Matters
Claude Code’s effectiveness scales with how well it understands your project. A bare CLAUDE.md with a few paragraphs is better than nothing. A generated environment with 12 specialized agents, 23+ skills, enforcing hooks, and documentation tailored to your stack is substantially better than that.
The goal of Armature is to collapse the distance between “starting a new project” and “having a Claude Code environment that works as well as the one you’ve spent months refining on your most mature codebase.” For teams adopting Claude Code at scale, that consistency matters.
The generated environments are designed to be owned and evolved. Everything is markdown files and JSON, readable, editable, and version-controlled alongside your source code. The /bootstrap skill helps you customize after generation. The Upgrade system keeps environments current as Armature’s templates improve.
Start with a quick-start template, run through the interview on your next project, or upload a PRD you already have. The environment is waiting on the other side.