What if your codebase is getting worse with every feature you ship? Going agentic is easy — going agentic without wrecking quality is the hard part. AI Forging is the discipline for handing AI whole units of work while quality and velocity compound instead of collapse.
Autonomy and discipline are two different axes. "Agentic" means you hand the AI a whole unit of work. "Vibe" means little discipline wraps it. Cross them and you get four very different places to live — including the trap almost nobody names: agentic vibe coding.
Click the map to open it full-size ↗
AI makes producing code nearly free. Without structure, every feature shipped makes the codebase worse — and eventually the AI itself starts hallucinating against the mess it helped create. This is the problem worth solving, and it outlives any single tool.
AI output silently diverges from your conventions. Small drift today becomes structural debt in six months — hidden behind a green CI badge.
Features ship fast while the codebase rots underneath. The rework cycle begins invisibly, then velocity collapses.
Hard-won decisions live in chat transcripts and individuals' heads. Nothing is codified. Turnover resets the clock.
No record of what was built, why, or by whose approval. Governance and regulatory blind spots.
It isn't a single tool. It's a philosophy, a methodology that serves it, and a concrete implementation of that methodology — three layers with very different lifecycles.
What goes wrong when we build with agentic AI, and why quality has to compound instead of decay. Tool-agnostic and the part that endures longest.
Spec → plan → test-first execution → refactoring in isolated sub-agents → knowledge captured so it scales. Framed as one approach, not the only one — others are welcome.
The open-source Claude Code plugin — with strong, opinionated bets on architecture. One implementation of the methodology. You could disagree with every opinion and still hold the philosophy.
A metallurgy metaphor: raw material becomes stronger through structured transformation — not by hoping for the best. Each pass through the forge leaves the codebase stronger than it started.
AI-powered TDD. Tests capture intent before a line of implementation exists — the double-entry accounting of software.
Intent, verified — not eyeballed.
After the tests pass, one fresh-context sub-agent per pattern reworks just the changed code — in parallel, no drift, no fatigue.
Consistency without human fatigue.
One correction, one pattern file. Adding the 50th costs no more than the 5th. No monolith, no context ceiling.
The system gets smarter, not heavier.
Nothing autonomous, nothing silent. Every proposal passes a human gate before it merges — reviewed at feature completion, not one step at a time.
The most important layer is the Why, and it belongs to everyone. The methodology below it is one route through the problem — yours might be better. The plugin is one implementation — there could be others, for other tools, stacks, and architectures. Take the ideas, build your own, and share what you learn.
A Claude Code plugin that runs the whole method — spec, TDD, pattern-driven refactoring, knowledge capture — with opinionated, domain-driven architecture on top. Built for established codebases that already feel the AI-generated sprawl. Prescriptive on purpose.
# Install superpowers (the TDD + sub-agent foundation) /plugin marketplace add obra/superpowers /plugin install superpowers@superpowers-dev # Install AI Forging /plugin marketplace add aiforging/aiforging /plugin install aiforging@aiforging # Then bootstrap a workspace /aiforging:setup
Symfony / PHP / Doctrine is the happy path today; other stacks work to the degree the conventions apply. Research preview — try it on something real and open an issue about what broke.