FullSpec framework for AI development with Claude Code and specifications

FullSpec: AI-Driven Development Framework with Claude Code

AI-assisted development often descends into chaos without unified architectural docs. FullSpec fixes this by formalizing the entire lifecycle from idea to release through a chain of specs that AI agents generate and maintain.

The Problem: AI Lacking Architectural Memory

The core challenge with LLMs like Claude Code is the absence of context for architectural decisions. AI cranks out code fast but forgets why the system is built that way. In a project with 25 microservices, this sparks major conflicts:

• Inconsistent encryption algorithms across neighboring services
• Mismatched API contracts
• Conflicting decisions from parallel sessions

Traditional docs fall short: they're either outdated or buried in red tape. AI needs fresh, complete, contradiction-free specs—and FullSpec delivers exactly that environment.

FullSpec Architecture: 23 Agents and 8 Phases

The framework structures development via formal docs that AI agents generate and validate. Users trigger /chain with a task description, like "implement OAuth2 auth," kicking off an 8-phase sequence.

Spec Levels

The chain produces four document levels with mandatory reviews at each:

• Discussion — requirements, success criteria, scope, and risks
• Design — system changes: services, API contracts, data models
• Plan Tests — test scenarios written before any code
• Plan Dev — tasks, dependencies, and execution blocks

Once specs are approved, the system auto-generates docs, creates GitHub Issues, writes code and tests, runs code reviews, and builds PRs.

Key Framework Mechanisms

Parallel Agent Workflows

Instead of one Claude handling tasks sequentially, FullSpec deploys 23 specialized AI agents:

• Design generator
• Test planner
• Coders for various languages
• Reviewers at every level
• Doc sync agents

During syncs, it spins up N agents in parallel—one per service.

Auto-Validation and Rules

The system packs 80+ validation scripts and 30 pre-commit hooks that check:

• Doc formats
• Structural consistency
• No secrets in code
• Commit message standards

16 contextual rules auto-load per file type: .ts → TypeScript standards, .py → FastAPI standards. Rules live in .claude/rules/ and apply seamlessly without extra prompts.

Living Specs and Conflict Checking

What sets it apart from rivals: the system spots and fixes code-spec mismatches. Post-commit, CONFLICT-CHECK runs:

• Halts on contradictions
• Pinpoints conflict level (Design, Plan Dev, etc.)
• Cascades spec updates top-down
• Keeps docs fresh across all dev stages

Comparison with Alternatives

| Criterion | FullSpec | Spec Kit (GitHub) | Kiro (AWS) | OpenSpec (Fission AI) |

|----------|----------|-------------------|------------|-----------------------|

| Type | Process framework | CLI toolkit | IDE (VS Code fork) | CLI framework |

| Requirements Formalization | Discussion with criteria | Constitution + Spec | Requirements (EARS) | Proposal |

| Architectural Design | Design with API contracts | Plan | Design (markdown) | Design |

| Pre-Code Test Planning | Plan Tests with TC-N numbering | No | No | No |

| Conflict Detection | Automatic + cascading updates | No | No | No |

| Living Docs | Auto-sync from specs | No | No | No |

| GitHub Automation | Issues, PRs, Reviews, Releases | No | No | No |

| AI Agents | 23 parallel | 0 | 1 (built-in) | 0 |

| Validation | 80+ scripts, 30 pre-commit hooks | 0 | 0 | ~5 |

| Brownfield Support | Not yet | Yes | Yes | Yes (focus) |

FullSpec covers the full dev cycle but ties to Claude Code and lacks brownfield integration for now.

Technical Specs

• 71 skills — slash commands for every process step
• 23 AI agents — parallel workers with specialties
• 80+ validation scripts — checks at all stages
• 30 pre-commit hooks — automated quality control
• 16 contextual rules — expands with new tech
• 8 process phases — from idea to production release
• Recursive standardization — self-builds by its own rules

Key Takeaways

• Low entry barrier — complex under the hood, but users just hit /chain and confirm via chat
• Claude Code only — built for this AI; others untested
• Russian docs — instructions and specs in Russian, but Claude handles them fine
• Greenfield only — works as a template for new projects; brownfield in progress
• Open source — MIT-licensed on GitHub

This project brings to life an approach where AI doesn't just spit out code—it thrives in a formalized process with living docs. It cuts architectural risks and boosts predictability for AI-using teams.

— Editorial Team