AI Coding Workflows — using the tools like a professional

Topic 82 of 90Module 11: Real-World Building3 min read

Module 8 explained why coding models got good; this topic is the user side — the workflow discipline that separates engineers who 10× with these tools from those who generate plausible bugs faster. The tool tiers first: autocomplete (FIM, ambient), chat-assisted (explain/draft/debug in conversation), agentic (Claude Code-class: reads the repo, edits files, runs commands — Topic 58's loop pointed at your codebase), and background agents (issue in, PR out, review async). The disciplines that matter run across all tiers:

1. Spec first — the prompt is a spec (Topic 54, applied to engineering). "Fix the auth bug" produces guesses; "login fails for emails with +; the validator in auth/validate.ts rejects them; fix the regex, add test cases for plus-addressing, don't touch the session logic" produces the fix. And the repo-level version: rules files (CLAUDE.md and kin) are system prompts for your codebase (Topic 55) — conventions, commands, architecture notes, forbidden patterns — the highest-leverage file-per-character in a modern repo.

2. Verification first — tests are the contract. Topic 66's whole thesis, wielded: the strongest agentic pattern going is write (or generate and review) the tests, then let the agent iterate until green — converting Topic 58's compounding-failure regime into retry-until-verified. Your role shifts from writing the solution to specifying the checkable success condition.

3. Decompose and review. Big-bang refactors are the compounding trap (0.95³⁰ again) — small scoped diffs, sequentially. And the line that must never move: read every diff before it merges. AI-generated code is confident in exactly the Topic 21 way — fluent, plausible, occasionally subtly wrong — and "AI wrote it" will never be an accepted root cause. (AI review as a second pass is excellent; as a replacement for your reading, it's the blind leading the blind.)

Where the tools are strong today: boilerplate, tests, migrations, glue, unfamiliar-API navigation, "make it pass." Where your judgment stays load-bearing: novel architecture, subtle concurrency, performance-critical paths, security boundaries. The honest skill shift: value migrates from typing code to specifying, decomposing, reviewing, and verifying it — which is to say, the senior-engineer skills appreciated and the junior mechanical ones depreciated. Plan your own development accordingly.

Summary

Professional AI coding = spec-quality prompts + rules files as repo constitutions + test-anchored verification loops + small diffs + non-negotiable human review — with your leverage moving up the stack from writing to specifying and verifying.

Mental model

You've been promoted to tech lead of a tireless, fast, occasionally-overconfident team: your output is now specs, task decomposition, and review quality — and the team is exactly as good as your tickets.

Mistakes to avoid

vague tasks to agentic tools, then blaming the model for guessing (garbage spec, garbage diff — the amnesiac-contractor standard applies to code tasks doubly); and merging unread diffs because the tests pass — tests verify what tests cover, and you specified the tests.

Exercise

Add a rules file to a real repo of yours: conventions, build/test commands, architecture in five lines, three "never do" rules. Then run the same non-trivial task through your coding agent with and without it, and diff the diffs. The delta is Topic 55's lesson, measured on your own code.