Girudo AI Conversion

For 2.0 I converted that process to an AI-based workflow. Design and frontend stopped being two sequential activities separated by a handoff and became one activity. There is no specification to write, no handoff meeting, no interpretation gap, and no round trip, because the person making the design decision is the same person the implementation happens in front of. This case study is about that conversion: what had to be built to make it work, what it changed, and what it cost.

An assistant is only as good as the context it is working from, and design context is exactly the kind that is never written down. Why this module exists, which competitor pattern was deliberately rejected, who signed off on this scope, what a term means in this product, what is still an open question rather than a decision: on a normal project all of that lives in Figma comments, call recordings, and the designer's head. A model cannot read any of it. Ask one to build a screen without it and it will produce something plausible, confidently, with invented product logic filling every gap you did not specify. At speed, that fills a codebase with decisions nobody made.

So the real problem was not learning to build with AI. It was that going fast is only safe if the knowledge behind the work is available in a form the workflow can actually use, and on a rebuild that knowledge was scattered across two years of a previous version.

The second half is the infrastructure that makes working at that speed safe. Before designing anything for 2.0, I built the workspace the project would run inside. A single command stands up the whole structure: external research covering competitors, feature comparison, pricing and market opportunities; internal product knowledge covering overview, per-module workspaces, personas, UX research, open questions, information architecture and sitemap; a rules directory; and an append-only log holding decisions, meeting notes, requirement changes and dated feedback. Every folder carries a readme explaining what belongs in it. The script is idempotent, so the same command repairs a workspace as easily as it creates one.

That structure exists so the context is retrievable at the moment of building rather than remembered. When a module gets built, its definition, its user flows, the research behind it, and the open questions against it are all in known locations, so the work starts from what the product actually is rather than from what seems reasonable.

Three phase gates keep the sequence honest even at speed: product knowledge, then research, then UX structure, each with named sign-offs and a logged transition. And one hard rule does the heaviest lifting: product detail is never inferred. Module names, features, user roles and business goals come only from what the product owner supplied, and anything unconfirmed goes to an open questions file with a named owner instead of becoming a confident sentence in a document. Going fast without that rule is just generating fiction quickly.

On top sits a suite of custom Claude skills for the work that repeats: competitor profiling split into creating and approval-gated refreshing, a UX visualization assistant for producing the right artefact for a question, feedback intake that categorises and deduplicates across a dated log and imports from design boards, a research writing partner, and a changelog generator driven by commit history.

The rules that survived were the ones with no judgement call attached. Everything written as a recommendation was skipped within a fortnight; the absolutes held. Not because they were better rules, but because a rule with a judgement call becomes a judgement call, and under deadline that resolves the same way every time. The routing table, which simply states where each kind of content goes, removed more friction than any single rule, because it retired a decision being made dozens of times a week.

The honest caveats are real. This workflow suits one person who can hold both roles, and I do not know how it behaves with two designers and three engineers, where the handoff is also a coordination mechanism rather than pure overhead. It puts unusual weight on typed, tested code, since the pace is only safe because the compiler and the test suite object loudly. And the August reset revealed how much of the first two months of documentation was not worth keeping, which is a tighter phase gate I should have enforced from the start rather than a discovery.