The Fastest Team Defines Before It Generates

The Claude Code skill collection that introduced Grill Me — Matt Pocock's mattpocock/skills repo — crossed 20,000 stars on GitHub in a matter of weeks, with the Grill Me skill itself singled out by the author as the one driving the surge. Its entire premise is to slow you down. Before it writes a single line, it interviews you — typically between sixteen and fifty questions, depending on how complex the change is — about what you actually want.

This should not be a viral hit. The market has spent two years optimizing the opposite reflex: shorter prompts, faster output, more lines per minute. And yet a tool whose value proposition is ask before generating is what the community is starring. The signal is worth reading carefully. It is not nostalgia for ceremony. It is the practical recognition that the fastest teams have been doing this all along — they were just doing it in their heads.

Software is still the expression of human intent. The speed of generation has changed. The need for intent has not.

The instinct that makes teams slower

The default move with a coding agent looks like speed. You type a request, the model writes a function, you accept the diff. The loop closes in seconds. Compared to the old workflow — search, read, write, debug — it feels like a different category of work.

It is not. It is the same work with the slow part hidden.

Every "fast" generation rests on a stack of assumptions: about the data shape, the failure modes that matter, the regulatory constraint that applies, the existing pattern the new code must respect. When you skip the definition step, you do not eliminate it. You let the model guess, accept its guess, and pay the cost later — in the bug that ships, the rule that was inferred wrong, the architecture that quietly drifted.

This is the trap behind Lightrun's April 2026 State of AI-Powered Engineering report, where 43% of AI-generated code changes were found to require debugging in production even after passing QA and staging — based on 200 SRE and DevOps leaders surveyed across US, UK and EU enterprises. The number is not about model quality. It is about teams generating before they have decided what they want.

What Grill Me is actually selling

Strip the framing and the skill is doing one thing: it is forcing the user to externalize intent before the model touches code.

The questions are not interrogation. They are the structured version of the conversation a senior engineer has with themselves before opening the editor. What is the input shape? What happens on partial failure? Is this idempotent? Does this need to compose with the existing retry layer? Who owns the rule that says we round down at this boundary? Senior engineers ask these questions in two minutes of staring at the wall. Junior engineers and non-engineers do not — and that is exactly where the model fills the void with plausible defaults.

By making the questioning explicit, the skill converts an invisible practice into a visible artifact. The artifact is the spec. The spec is what makes the next generation worth running. And the spec is what survives the model upgrade six months from now.

This is intentionality made operational. Not a doc. Not a meeting. A gate that you cannot pass without declaring what you actually want.

Why founders feel this first

For a founder running a team of five, the math is brutally legible. Every regenerated feature, every "we already built this but it doesn't quite fit," every three-day debugging session on code nobody understands — those are the costs of skipping definition. They do not show up as a line item. They show up as a roadmap that slips and a team that feels busy without shipping.

The teams that ship fastest at this scale are not the teams with the best models. They are the teams that pay the definition tax once, up front, in writing, and then let generation collapse the implementation cost. The ratio matters: ten minutes defining and forty seconds generating beats forty seconds prompting and three hours reconciling. Always.

This is not theoretical. The same recurring complaint that surfaces in developer forums — that the team has lost grip on its own codebase — tends to come from teams that inverted the ratio: they treated speed as a function of how fast the model can type. The teams quietly compounding velocity are running the Grill Me loop with or without the skill. They are interrogating intent before they let the model produce.

The contour of a definition-first workflow

For a founder or tech lead trying to install this discipline without slowing the team down, the move is concrete. Not a process document. Three pieces of behavior:

Refuse to generate without a written intent. One paragraph. What is being built, what it must guarantee, what it must not do, who owns the rules it encodes. If you cannot write the paragraph, the model cannot help you. It will only help you faster into the wrong thing.

Make context part of the intent. Half of the bad generations are not bad models — they are good models with bad context. The intent paragraph should answer: what existing patterns must this respect, what regulatory or business rule applies, what constraint is non-obvious from the surrounding code. Context that the model has to infer is context that ships as a defect.

Treat the spec as the artifact, not the code. The code is regenerable. The intent that produced it is not. If your team is keeping the diff and discarding the prompt and context that produced it, you are accumulating output without accumulating decisions. Six months from now, you will not know why anything is the way it is. Neither will the model.

These three moves are GAISD's intentionality and context quality controls expressed at startup speed. They cost minutes per feature. They save weeks per quarter.

The competitor that does not exist yet

The pitch most coding tools are running in 2026 is faster output. The pitch the market is starting to reward — quietly, through stars and threads and the choices senior engineers make — is better definition. Grill Me is the early signal. It will not be the last.

The teams that will look fastest in eighteen months will not be the ones with the most generated code. They will be the ones whose generated code rarely needs to be regenerated, because the intent was right the first time. That looks slow on a stopwatch and fast on a roadmap.

If you are running a team and feel busy without shipping, the question is not which model to switch to. The question is whether your team is allowed to generate without first declaring what they want.

If the answer is yes, that is your next constraint. Sign the manifesto at gaisd.dev/sign, adopt principle one — human intentionality — and let your team feel the difference between speed and motion.