METHODOLOGY
A repeatable, verifiable pipeline, driven by a Spec
Every exhibit runs the same closed loop. It is the discipline you already expect from a strong team, a written spec first, tests as the gate, honest scope changes, with agents doing the heavy lifting. Here is the shape of it, and the tooling that makes it repeatable.
iterate When verify fails, loop back to implement. Learn then feeds each session's lessons back into the repo context, memory, and skills, and Claude Design ⇄ UI runs on every visual change.
A 60 to 90 second screen capture of one real loop, PRD to green verify, is coming here. Until then, the timeline and commits on each exhibit are the receipts.
The kit
An open-source agentic-dev-kit: Claude Code skills, a custom MCP server, and PRD templates, dropped into each repo. The portfolio is built by dogfooding it end to end.
The PRD loop
Every feature starts as a behavioral PRD: scope, tasks, and acceptance criteria. A grill step then pressure-tests it with relentless polling rounds until the design, behavior, and dependencies are locked. The agent implements against it, and a failing check loops straight back to implement.
Spec + test driven
The PRD is the spec, so every build runs against a written contract instead of guesswork. Tests are written from that spec and run in CI, gating each ship. Two ends of one loop: write it down, then prove it green.
Claude Design → UI
Visual work flows from a Claude Design handoff (tokens + components) into the live UI. A design-sync skill keeps the shadcn token contract and the implementation aligned on every visual change.
MCP + skills
A project MCP server exposes schema introspection, exhibit scaffolding, and deploy status. Skills (prd / prd-grill-me / implement / verify / design-sync / reconcile / learnings) drive the repeatable steps.
Closed-loop verify
Lint, typecheck, tests, Lighthouse, and CI form the gate. Nothing ships until the loop closes green, and the proof is the public GitHub history.
Learn: the toolchain compounds
After shipping, a learnings step reflects on how the session actually went: what worked, where the agent fought the tools, and what the human had to correct. Those lessons are written back to where the next agent will read them, the repo context and rules, the persistent memory, and the skills themselves, so each run starts from a better-prepared toolchain. The portfolio improves the kit that builds it.
This loop travels.
The skills and MCP server are open source, and the same loop that built these exhibits can run inside your team's repos. If you're hiring an engineer who works this way, or you want help making agents productive on your codebase, get in touch.