Most teams using AI coding assistants are doing it wrong. They open a chat, paste some context, say "build me X," and hope for the best. The output is inconsistent. The code doesn't follow existing patterns. Tests are an afterthought. Every feature feels like a coin flip.
I had the same problem. So I built an entire software development lifecycle that runs on agents — not as a novelty, but because I was tired of rework.
The bottleneck is context, not capability
When you ask an AI agent to "build feature X," it starts coding immediately. No research. No pattern discovery. No test strategy. It invents new patterns instead of following existing ones. The output looks like code written by someone who joined the team today and skipped onboarding.
So I built a system that front-loads context before any code is written. It's a single Claude Code skill called /sdlc that orchestrates six phases:
/sdlc idea → 1-idea.md
/sdlc research <feature> → 2-research.md
/sdlc plan <feature> → 3-plan.md
/sdlc build <feature> → 4-build.md
/sdlc review <feature> → 5-review.md
/sdlc context <feature> → 6-context.md
The highlights
Research swarms — 4 independent agents investigate each feature in parallel: codebase analysis, library docs, market research, and a contrarian devil's advocate. They don't coordinate. Independent perspectives surface blind spots that groupthink misses.
Pattern baselines — Before any code is written, the plan phase finds existing implementations that do the same kind of thing. Every file change in the plan references a specific "Pattern From" file and line number. The agent follows the template instead of inventing.
TDD-driven builds — Red, green, refactor for every unit. A regression gate (full test suite + lint + typecheck) runs after each unit goes green. No skipping.
Adversarial review — Not a friendly once-over. Five dimensions: plan compliance, pattern compliance, security, correctness, and performance. The verdict is SHIP, FIX AND SHIP, or BLOCK.
Baseline enforcement — A rule engine in CI that encodes every lesson into automated checks. Banned dependencies, architecture tests, and ratchets that force one-way progress on legacy patterns. The review phase feeds directly into baseline — creating a flywheel where each feature makes the next one harder to ship with bugs.
What it looks like in practice
For a medium-sized feature, the full lifecycle takes about 45 minutes of my time:
| Phase | My Time | Agent Time |
|---|---|---|
| Idea | 5 min | — |
| Research | 4 min | 5–10 min |
| Plan | 10 min | 5 min |
| Build | 7 min | 15–30 min |
| Review | 3 min | 5 min |
| Context | 1 min | 2 min |
I'm a reviewer and decision-maker, not a typist. The agents do the reading, the coding, and the testing. I approve the plan and the ship decision.
The full article covers the coordinator pattern, how ratchets enforce one-way progress on tech debt, the TDD rules I learned the hard way, and how the review phase's lint rule extraction creates a self-enforcing codebase.
Top comments (0)