How I build software with AI-assisted development.
I use Claude Code with structured workflows that turn ideas into production code. The methodology is systematic: brainstorm, plan, implement with parallel agents, review, and verify.
User
Intent / Requirements
Design Spec
Implementation Plan
Parallel Agents
Isolated worktrees
Verified, Tested Code
Planning & Architecture
Structured Brainstorming
Every project starts with collaborative design exploration. I work through requirements, constraints, and trade-offs before writing a single line of code. The output is a design spec that captures architecture decisions and their rationale.
Design Specs
Written specifications document what we're building and why. They go through automated review loops to catch gaps and ambiguities before implementation begins.
Implementation Plans
Specs become step-by-step plans with exact file paths, code patterns, and test strategies. Each task is small enough to implement in a single focused session.
Multi-Agent Orchestration
Parallel Agents
Independent tasks run in isolated git worktrees with dedicated agents. Each agent gets precisely crafted context — just what it needs, nothing more.
Context Isolation
Fresh agents per task prevent context pollution. The controller coordinates, dispatches, and reviews. Agents implement, test, and report.
Two-Stage Review
Every task goes through spec compliance review first, then code quality review. Issues get fixed and re-reviewed in a loop until both pass.
Context Management
CLAUDE.md Files
Project-specific instructions that persist across sessions. Architecture decisions, coding conventions, and gotchas are captured where they can inform every interaction.
Memory Systems
Structured knowledge about projects, preferences, and decisions that carries forward. Not just what happened, but why it matters for future work.
Scoped Instructions
Each project and sub-project gets its own context. Agents working on the kernel driver don't get confused by web frontend conventions.
Code Review & Verification
Automated Checkpoints
Review gates between tasks catch issues early. Spec compliance ensures nothing is over-built or under-built. Code quality review ensures the implementation is clean.
Test-Driven Development
Tests are written before implementation code. The red-green-refactor cycle keeps the codebase honest.
Verification Before Claims
Nothing is declared 'done' without running the actual verification commands and confirming the output. Evidence before assertions.