The AI-Assisted Engineering Workflow: Feed Context, Use Skills, and Rethink Code Review
Teams that keep treating AI as an intern who guesses at missing requirements waste tokens and ship hallucinated fixes. This workflow shows the infrastructure and process changes needed to make AI autonomous enough to inherit full tasks, with humans reviewing only plans and evidence.
Making AI write dependable code in production starts with two conditions: enough correct context and explicit instructions. Context comes from opening up the codebase and external systems to the AI—maintaining AGENTS.md files with engineering rules, wiring read-only access to logging, monitoring, production databases, ticketing, chat history, and Git commits via MCP or API keys. Instructions get codified as Skills, instruction files in the repo that turn a vague "fix this bug" into a defined root-cause investigation: pull real evidence from logs and the DB, check the upstream and downstream chain, and only then propose a change.
Testing and review then shift shape. Tests target business behavior, not internal function signatures, with integration tests for non-UI code and Playwright E2E for web. A Replay system guards prompt-dependent features by only running related tests when a prompt changes. Code review stops being line-by-line; reviewers check the AI's PR description for solid evidence and inspect only high-risk files like SQL migrations or permission config. Teams then pick a mode: the cautious one, where humans approve the plan before AI executes the rest, suits core business and ToB products; the aggressive one, where AI merges and ships directly, works for internal tools and personal projects. Both need a daily automated scan that flags anomalies and alerts to Slack or Feishu, with AI handling the fix from there.
The payoff: the human becomes a decision-maker and validator, not a code writer. That demands deep business knowledge and a broad technical foundation, because the value of the engineer moves to asking the right questions and judging AI's plans.
The bottleneck in AI-assisted development is not model capability but the quality of context and instructions, making it an infrastructure and documentation problem rather than a coding problem.
Shifting code review from line-by-line to evidence-based checking redefines the reviewer's job: the real check is whether the AI's root-cause reasoning and plan hold up, not whether the code is aesthetically clean.
The cautious/aggressive split is a risk-appetite tradeoff; the aggressive mode only works when the cost of a bad merge is low, which is why it's reserved for internal tools and personal projects.
Calling for engineers to become product engineers and to maintain broad full-stack knowledge reinforces that the differentiator in an AI-assisted world is the ability to ask good questions and judge AI's output, not to write tricky code.
That example about missing an item when flipping pages hits the point—sorting only by creation time and having two orders in the same second causes pagination misalignment. This root cause can't be guessed from the code alone. Without logs and a read-only database, AI can only add front-end filtering to cover the surface. I accept this "evidence first, then act" order. But I don't fully agree with "code style just needs to be roughly acceptable." It works for small projects, but in a larger codebase, the "roughly acceptable" code AI accumulates becomes the next spaghetti mountain in three months. Review still needs a human to keep an eye on critical files. Is your team's "root cause" Skill written in the repository for everyone to share, or does each person maintain their own copy?
They're all shared in the repository; important skills go in the repo.
Actually, we reviewed code at first, but later we couldn't keep up. Now we only set repository directory conventions—for example, which frontend directories, what goes into `components` and `ui` directories, what each backend module directory holds. We don't manage the detailed code inside.