AI Took Over Tactical Code; Strategic Software Engineering Is What Remains
Software engineering discipline now determines how much value AI coding actually delivers, because the model handles the tactical layer while a human owns the strategic layer. Teams that add deterministic checks and a shared vocabulary get reliable AI output; teams that trust the model's confidence inherit unverified, tangled code that fails months later.
AI coding has shifted the bottleneck from knowledge to judgment. Syntax, APIs, and usage patterns are nearly free; the scarce part is deciding whether a module should exist, where its boundaries sit, and where complexity should hide. Tactical work, such as fixing a local bug or adding a field, surfaces errors in minutes and AI covers most of it. Strategic mistakes, like a tangled data flow, can take months to show up, and AI is only useful there when it makes that feedback loop shorter.
A concrete version of that idea lives in Matt Pocock's open-source skills repo. Tasks are split vertically into tracer bullets: each small slice crosses database, API, page, and tests so it can be demoed and verified on its own, and the slice should fit one fresh context window. Some changes, like altering a field type with thousands of call sites, cannot be split and need the add-migrate-delete sequence. Before any implementation, the two most popular skills, grill-me and grill-with-docs, force the AI to ask questions, because a model that will not ask turns a half-understood requirement into confidently wrong code.
Feedback loops make the difference. The workflow pairs a shared CONTEXT.md glossary derived from DDD's Ubiquitous Language with a red-green test discipline: write the failing test first, and derive expected values from outside the implementation. Code writing and reviewing happen in separate sessions, with coding standards sent only to the reviewer. Constraints that can be enforced mechanically belong in lint rules, type checks, or pre-commit hooks rather than CLAUDE.md, because deterministic failure costs nothing on success and cannot be talked out of.
Strategic mistakes carry a nine-month feedback delay, so the most useful thing AI can do is shorten that loop, not generate more code.
AI will not ask for clarification, so requirements elicitation becomes a hard prerequisite; a model that charges ahead on a half-understood spec turns ambiguity into confidently wrong code.
Tests that reuse the implementation's own values are structurally blind; the 'correct answer from outside' rule separates genuine regression protection from ritual.
Separate write/review sessions work because an LLM is a poor self-critic inside the same context; changing the context is a cheap substitute for a second engineer.
Mechanical enforcement beats prompt instructions because a lint failure is deterministic and free when passing, while a CLAUDE.md rule is probabilistic and costs tokens on every call.