Context
AI tools make it fast to go from idea to shipped code, but speed alone creates a new problem: what gets built, what gets documented, and what was originally planned all start to drift apart from each other. I wanted a repeatable, controlled way to go from a rough idea to a shipped feature without losing track of that thread.
Problem
Most "I used AI to build this" stories are a single prompt-to-code loop with no system behind it. That works for a demo. It doesn't hold up for a real internal tool that other teams depend on and that needs to keep working as scope grows.
My Role
I designed and orchestrated the agent ecosystem end-to-end, then used it to build TCWTable — an internal employee management system giving the whole company access to org info, data, and performance reviews.
Team & Stakeholder Dynamics
TCWTable's scope grew organically rather than from a single upfront spec: it started as an RBAC and access-control build, then grew into profile pages with forms, then an org chart, then a full company seating chart. I worked with designers on layout as the scope expanded, with ongoing collaborative ideation throughout instead of one static handoff.
Process & Decisions
I merged agents from two systems — Claude Superpowers and Gstack — rather than relying on either alone. Gstack's "office-hours" prompt refined the initial idea; Superpowers' brainstorming sharpened it further. I used plan functions to break the work into pieces, running both agents sequentially to write and refine briefs and prompts before any actual build started. Two other agents ran continuously alongside the build itself: a documentation agent that generated a living document with every PR, anchored back to the original PRD as the single source of truth, and a Playwright-based test-driven-development agent that wrote tests before the corresponding feature was built, not after.
Outcome
TCWTable shipped as a real, adopted internal tool — RBAC through to profiles, org chart, and seating chart, each stage managed deliberately rather than sliding into scope creep. More importantly, the agent ecosystem itself is repeatable: documentation and source-of-truth stayed in sync with what was actually built, closing the usual gap between plan, docs, and shipped product.
Reflection
The interesting part isn't that AI wrote code faster — it's the systems thinking underneath: treating documentation and test-writing as agents with their own responsibilities in the pipeline, not afterthoughts bolted onto a single coding prompt. That's the difference between "I used AI to build something" and having a process that keeps working as the thing you're building keeps growing.