Agent Coding Workflow

topic · 225 sources

Coding agents have made generation nearly free, so the whole of the practitioner's craft has migrated downstream to where the cheap part stops: verification, comprehension, and the harness that makes delegation safe. The sharpest single finding in the evidence is that these two things do not move together — across a large codebase, autonomous coding agents raise commits by roughly 180% while shipped releases rise by only about 30%, because what governs shipping is review, verification, and human attention, not typing. The workflow that wins is therefore not the one that generates fastest but the one that has built the tightest loop from intent to proof: tests that run without being asked, context curated like code, specs kept as the durable artifact, and a human operator who stays able to understand and judge what the fleet produces. The bottleneck was never typing; it is now thinking speed, taste, and the discipline to verify before shipping.

The Argument

The Maturity Spectrum

Five Levels from Spicy Autocomplete to the Dark Software Factory gives the cleanest framework: five levels from manual coding through task offloading, collaborative partnership, human-in-the-loop management where AI becomes the senior developer, autonomous specification where developers act as product managers, and finally fully autonomous black-box automation — the dark factory. Shapiro notes that 90% of AI-native developers sit at Level 2 and most teams plateau at Level 3, where you are not coding anymore but not really designing either — you are reading.

Compound Engineering maps a similar ladder through five stages of adoption, from manual development through chat-based assistance, agentic tools with line-by-line review, plan-first PR-only review, idea-to-PR, and finally parallel cloud execution. The critical claim: most developers plateau at Stage 2 — approving every action — because they have not built the systems that make delegation safe. The compound step — capturing learnings, updating CLAUDE.md, creating new agents, codifying patterns — separates productive teams from ones that just go fast. Its 50/50 rule is the most concrete prescription: half of engineering time on features, half on improving the system.

The ladder is not linear per task. Simon Willison — Engineering Practices That Make Coding Agents Work identifies a rung that arrived only recently: not reading the code. Willison calls this "clear insanity" but argues it becomes possible if you shift energy into making the agent prove the code works — through TDD, manual testing by the agent, and conformance suites. This is a qualitatively different posture from both the careful Level 3 reviewer and the Level 4 spec-writer, and it is the point where the spectrum stops being about trust and starts being about proof.

ThoughtWorks Future of Software Engineering Retreat adds the structural insight: a middle loop of supervisory engineering work now sits between inner-loop coding and outer-loop CI/CD — decomposing problems into agent-sized packages, calibrating trust in agent output, and keeping architectural coherence across parallel streams of generated work.

How Practitioners Actually Work

How Boris Uses Claude Code reveals the creator's own setup: 5–15 parallel sessions, plan mode before execution, CLAUDE.md as team memory checked into git, and verification as the force multiplier that "2-3x the quality." Cherny runs one large model with thinking rather than a smaller one with corrections, on the grounds that fewer retries beat a cheaper model. Addy Osmani's Workflow is the responsible professional's version: start with a detailed spec.md — "waterfall in 15 minutes" — work in focused chunks, review like a senior engineer, and treat classical practice as more critical than ever.

Matt Pocock — Grill Me, Then Go AFK turns planning into an interview: a "grill me" skill interrogates the developer question by question until a shared design concept exists, then a PRD the human deliberately does not read, then a Kanban board of vertical-slice issues that agents implement away from keyboard. Pocock's two structural claims deserve weighing against the rest of the evidence: models have a "smart zone" of roughly the first 100k tokens and degrade quadratically beyond it, and "bad code bases make bad agents." Loop Engineering is the generalisation of the same move — "replacing yourself as the person who prompts the agent." Osmani's components (automations, worktrees, skills, connectors, sub-agents, state) describe the loop; his three warnings describe the cost: verification still sits on the engineer, comprehension debt grows with every loop, and designing the loop is the cure when done with judgement and the accelerant when done to avoid thinking.

Claude Code on the Go pushes the envelope differently: six agents on a cloud VM supervised from a phone, with push notifications when Claude needs input — when runs take hours, you are not coding from your phone, you are supervising from it. Don't Wait for Claude diagnoses the real bottleneck: it is not Claude's speed but the human's ability to hold parallel sessions without losing context; externalising state so resuming requires no mental recall turns four work cycles per hour into twelve.

Inside the AI Workflows of Every's Six Engineers shows six engineers at one company converging on planning-first, multi-model, guardrail-heavy workflows while diverging on tools, models, and review strategy. Claude Code Cheat Sheet documents the feature density underneath: 30+ slash commands, a four-level memory hierarchy, hooks, on-demand skills, and MCP. How Intercom Uses Claude Code is the most complete enterprise deployment published — 13 plugins, 100+ skills, hooks that intercept raw gh pr create, OpenTelemetry observability, and a session-end classifier that files gaps to Slack with pre-filled issue URLs. Claude Code is a Beast — Tips from 6 Months of Hardcore Use documents a solo dev rewriting 300k LOC with skill auto-activation and 11 subagents; Claude Chic and Agentic Engineering at Kenn are the tools and team process behind Wes McKinney's version, where "vibe coding is not caring at scale" and the human-operator loop is the whole point.

The Non-Coder Dimension

Two Kinds of User Are Emerging identifies a divide between AI power users and casual users, but the surprise is that many power users are non-technical — the finance person converting a 30-sheet Excel model to Python "almost one-shot" is a different disruption than the engineer speeding up. vibes-cli targets people who do not code at all; life-system applies the same tools to personal productivity. AI Killing B2B SaaS and The Road Runner Economy argue the democratisation threatens software businesses — Raford, with zero prior coding experience, built nine substantial projects in weeks — while HN RIP Low-Code 2014-2025 captures the parallel flip in the build-versus-buy calculus.

Verification: The Force Multiplier

The single most consistent finding across the evidence is that verification, not generation, is the force multiplier. Writing Code vs. Shipping Code gives it a number: autonomous coding agents raise commits by 180%, but that cumulative effect falls to 50% for the number of projects and to 30% for actual releases — the weak-link hypothesis, with an estimated elasticity of substitution of 0.25 between AI and human effort. The system ships at the speed of its slowest human-verified constraint, which is why every serious workflow in this page spends its attention downstream of generation. Software Engineering at the Tipping Point generalises it: AI is a 10× amplifier, not a director, so weak fundamentals amplify into mess and strong ones into leverage.

Building low-level software with only coding agents validates the pattern at scale: Pixo, Lee Robinson's Rust image compression library, produced 38,000 lines and 900+ tests for $2,871 with zero hand-written code — but Robinson made hundreds of architectural decisions. Building 200+ Integrations with OpenCode arrived at a 3:1 guardrail-to-generation ratio, because agents optimise for task completion regardless of accuracy. Poor Man's Loop Engineering reduces the whole discipline to two ingredients: the agent must be able to test its own work, and someone other than itself must review it. Don't Fear the Dark Factory reframes the concern — a dark factory is "just a really simple loop" of sessions plus a validation harness — and Simon Willison — Engineering Practices That Make Coding Agents Work makes the same point harder: "Tests are no longer even remotely optional. Tests are — they're free now."

Designing Agentic Loops names the meta-skill — choosing tools, guardrails, and success criteria so YOLO-mode agents converge — and prefers shell commands over MCP because agents already know curl, jq, and ffmpeg. Dmitry Sotnikov's LLM Workflow names the mechanism: the loop is a genetic algorithm and tests are the selection pressure, which is why a solution that is not mostly right on the first shot should be reverted rather than debugged. Guardrails and Feedback Loops and Principal Drift reach the same conclusion from the governance side: mechanical enforcement does not degrade the way prompt-level instruction does, and the one rule that survives every risk tier is never to let the agent that authored a change be its only reviewer.

Context Engineering: The Harness Matters More Than the Model

How Claude Code Works in Large Codebases is the official position: the harness matters more than the model, and its seven components — CLAUDE.md, hooks, skills, plugins, LSP integrations, MCP servers, subagents — are the extension surface. The New Software Lifecycle sharpens the claim to a ratio: an agent is roughly 10% model and 90% harness, and most agent failures are configuration failures, which is encouraging because configuration is fixable without waiting for better models. Osmani's advice to leaders is the pithiest version of the verification thesis: "Set the bar at the eval, not the demo."

A Guide to Claude Code 2.0 names the discipline — "the art and science of curating what will go into the limited context window" — against sessions running 200K–500K tokens with effective windows at 50–60%. Intent Layer makes the argument from the other direction: agents fail on large codebases because they lack the tacit knowledge senior engineers carry, and folder-boundary AGENTS.md files cut token consumption from 40K to 16K in one case. CLAUDE.md (Universal) distills the file to six token-efficient rules; Writing a Good CLAUDE.md argues it must be short, universal, hand-crafted, and never auto-generated, because frontier models follow roughly 150–200 instructions and Claude Code's system prompt already spends about 50.

Benchmarking AGENTS.md Changes is the one empirical test, and it is a caution: the best AGENTS.md iteration improved training-set performance but regressed on a clean holdout — footprint widened, tokens climbed, review correctness dropped. The failure mode is not "everything gets worse" but "enough gets better that you miss the damage." Pre-Commit Lint Checks and claude-ctrl make the opposite-direction argument: a linter is the guardrail that cannot be talked around, and "an instruction that lives only in model context is not a constraint."

Talking to Transformers supplies the mental model — attention as budget, domain language as compression, inhibition over instruction — echoed by Code Field and How to Effectively Write Quality Code with AI, whose sharpest line is that every decision you do not take and document will be taken for you, usually badly.

Platform Engineering as the AI Control Plane folds harness engineering into the existing discipline: it is platform engineering with an AI-specific layer, and the prediction is that more engineers will end up building the harness than the product, because the harness is now the harder part. Managing AI Coding Costs at Scale adds the economics: chase the efficiency frontier rather than the intelligence frontier, and treat context bloat as the hidden cost driver — at Databricks, simple harness and caching tuning cut generated tokens by roughly half with no quality loss. The Economic Benefit of Refactoring is the most satisfying close to the argument: Fowler measured an 83% drop in input tokens from refactoring agent-generated code, not by deleting lines but by decomposition that let the agent read only the files it needed — refactoring helps reading far more than writing, and it compounds across every future change.

Specs as the Durable Artifact

When generation is cheap, the specification becomes the primary artifact. Specifications as the Product captures the shift: the spec is what you want the software to be, and it endures when the code is disposable. The AI-Native SDLC Playbook scales this to the whole lifecycle — every stage commits an artifact the next stage reads (intent.md → spec.md → plan.md) — and How to Write a Good Spec for Agents gives the five principles, including the "curse of instructions" and the three-tier boundary system (Always do / Ask first / Never do).

Structured-Prompt-Driven Development treats prompts as version-controlled delivery artifacts with the golden rule "when reality diverges, fix the prompt first"; Spec-Driven Development models specs, tests, and code as a triangle where implementing improves the spec; OpenSpec treats specs as descriptions of current behaviour with deltas for intent-based review; Specsmaxxing argues for YAML acceptance criteria with stable IDs threaded through code and tests. recursive-mode is the file-backed, phase-gated variant — each phase produces one locked document, audited phases loop draft → audit → repair → re-audit, and the whole rationale survives in the repo rather than the chat. SDD Case Study — 13 Apps in 70 Days is the strongest field result for the family: thirteen applications shipped solo in seventy days, because "the agent is a fast bricklayer with no blueprint" and the spec is the external memory you give it.

Code Field pushes back: a four-line prompt of pure negations lifted bug detection from 39% to 89% in its tests, because inhibition shapes LLM behaviour more reliably than instruction — let the code emerge smaller than your first instinct. The Cost YAGNI Was Never About reframes the oldest heuristic for the agent era: YAGNI was never thrift — it was two pieces of price theory, the Optionality Bill and the NPV Bill. Free generation does not weaken YAGNI; it makes the violation cheaper to commit, which is worse — and you comprehend the speculative structure less because you did not write it. The Plan Is the Program catches the shift in a phrase — the plan becomes the atomic unit of work — and AI for Product Management shows the same structure outside engineering: the magic is in how you combine structured context, not any single prompt.

The Human Role: Taste, Judgment, and Cognitive Stamina

Radical Accountability argues AI eliminates the excuse of insufficient engineering time — taste is all that remains. The Mythical Agent-Month extends Brooks: agents crush accidental complexity but generate new accidental complexity, and essential complexity — deciding what to build — was always the hard part, with a "brownfield barrier" somewhere past 100 KLOC. The Claude C Compiler makes the point technically: AI implements known abstractions well but invents nothing new. Automatic Programming draws antirez's bright line: programming is now automatic, vision is not.

On a Year of Multi-Model Development quantifies the variation — 25–71× acceleration depending on domain specificity — and its construction-trade taxonomy (Claude the architect, Codex the drywall contractor, Gemini the surveyor) is the most practical characterisation of model strengths in the wiki. Probabilistic Engineering and the 24-7 Employee names the asymmetry: "generation has become cheap, but validation has not," and the failure mode is not collapse but slow, silent degradation. Simon Willison — Engineering Practices That Make Coding Agents Work identifies the surprising constraint — cognitive stamina: keeping three or four agents busy at full throttle leaves Willison "done for the day," which is "what saves us," because one engineer cannot replace a thousand.

AI Zealotry makes the senior-engineer case — experienced engineers are best positioned because they can distinguish quality from slop — while Opus 4.5 Changes Everything records the ambivalence of a veteran watching the craft become trivial, and Gas Town After 10,000 Hours of Claude Code refuses the pure-delegation model: "Even if I am vibe engineering, I still care about the code. I still look at it."

The Cognitive Cost

Cognitive Debt names the structural problem: "code has become cheaper to produce than to perceive," production velocity now exceeds comprehension velocity, and the deficit is invisible to productivity metrics until failures expose it. Agents and Acquiring Debt sharpens it to the agentic case: agents do not eliminate debt, they shift when it is acquired — and the AI-native type is comprehension debt, "the new highest-interest loan you can take out against your code," accepted without agreement when you LGTM an edit you did not understand. "Every agent is the new hire on day one, forever." Understand to Participate and The Joy and Power of Understanding supply the counter-argument in normative form: understanding deeply is a prerequisite for staying an active collaborator, not a luxury, and the models are "force multipliers — but we must have the force first and keep it strong." Silently Resolved Ambiguity Is Comprehension Debt of Intent names the most senior form of the debt: when an agent resolves an ambiguity silently, a decision is made with no signature, and the only fix is provenance — knowing whether an outcome traces to something you authored, a verifiable reference, or a statistical guess.

acceleration-flow describes the psychological experience as slot-machine gambling — near-misses, abstracted token costs, a high from the rate of change rather than the capability — and Breaking the Spell of Vibe Coding develops it into an addiction model with a roughly 40% gap between perceived and actual productivity (developers thought they were 20% faster and were 19% slower in a METR study). Slowing the Fuck Down prescribes deliberate friction — agents do not learn from their mistakes, so the pain signals that once triggered refactoring are gone — and Slowing Down in the Age of Coding Agents offers the most unusual response: reading agent-produced design documents on an e-ink tablet with a pen, because the physical act of forming letters forces the thought to sit still. The Cult of Vibe Coding Is Insane rejects the ideology outright — "pure vibe coding is a myth," and even the never-look-at-code developers are building plan files, skills, and rules; the framework is the engineering. Compound Engineering offers the systems answer to all of it: do not rely on willpower to slow down, build infrastructure that makes speed safe.

Agents at Scale: The Overnight Fleet

RepoMirror put Claude Code in a while loop overnight — six codebases ported, roughly 1,100 commits, $800 — and the key finding is that a 103-word prompt beat a 1,500-word one. Agent Flywheel packages a one-command VPS installer for 10+ agents at $440–656/month, pitched against a $5,000/month junior. Coding Agents and Complexity Budgets recounts Robinson's $260 weekend migration and the insight that "the cost of abstractions with AI is very high."

TextForge Case Study shows the six-layer discipline that makes greenfield generation production-grade — planning mode, reference architectures, skills, PRDs, verification pipelines with snapshot testing, and periodic human-led refactoring. The Lifecycle of a Swamp Issue implements a five-phase state machine so "the agent physically cannot skip steps"; AI-Driven Development Life Cycle proposes "bolts" — cycles measured in hours — across inception, construction, and operations; agent-pr-replay derives steering rules by replaying merged PRs and measuring the gap against real human solutions.

What a User Story Actually Costs in a Dark Code Factory is the first honest metering of the fleet: 7.7 million tokens and $10.88 per story, with 95.4% of tokens as cache reads — "a dark code factory is mostly a reading machine that occasionally types," and the code is no longer the expensive artifact. Dev Machine Foundry is the cautionary tale from the other end: Schillace's dev machine mapped 1,111 obscure OOXML properties but never built a basic ruler, which sat in the candidate list for 22 sessions because the reliable green checkmark always won. "The machine is honest, but it isn't strategic. Strategy is still my job." Lean Software Production restates the discipline positively: the core question is "what can't the agents do?", and the work becomes engineering the system that produces the software.

I Don't Want Your PRs Anymore argues LLMs have inverted open-source economics — maintainers can generate code faster than they can review stranger PRs — and If AI Is Doing the Investigation, Version the Investigation prescribes committing the session transcript alongside the change so the reasoning does not vanish with the terminal tab. Scaling LLMs to Larger Codebases divides investment into guidance and oversight and gives the blunt imperative: "Read every line of generated code. Just because you told an LLM to sanitize inputs, doesn't mean it actually did." A Practical Guide to Brownfield AI Development is the best brownfield piece in the wiki: tests as system boundaries, documentation as context, incrementalism as risk management, and the counterintuitive point that speed enables boldness — "the faster you can fix things, the bolder you can be about breaking them."

Organisational Adoption

Minions — Stripe's One-Shot Coding Agents is the most significant deployment: 1,000+ unattended PRs per week on hundreds of millions of lines, with a North Star of "a pull request produced without any human code." Uber — Agentic Engineering Shift adds the caution that scale is not free: Uber's agentic shift saw costs rise at least 6× since 2024, to the point of CFO-level approval — and activity metrics no longer satisfy the finance org, which wants revenue impact. Inside OpenAI's In-House Data Agent shows the same pattern in a different domain — the hard problem is making the company's data reality legible through six context layers, not model intelligence.

Agentic Software Engineering (Hassan) is the canonical text, treating agentic SE as an engineering discipline — actors, process, artifacts, tools, and four trust disciplines — with the refrain that a fool with an agentic tool is still a fool: speed without an engineered system of constraints scales mistakes faster than value. Laura Tacho — Data vs Hype supplies the sceptical data layer: adoption is not transformation, and outcomes vary far more across companies than the marketing would suggest. Continuous AI extends the loop to the delivery pipeline — CI/CD plus the automation of the subjective judgments that used to block it.

The Mobile and Community Layer

The tools are proliferating: happy solves the "I started a session and need to leave my desk" problem; MobileVibe connects a phone to a desktop machine; Claude Sidecar runs a parallel AI window sharing context with other models; Claude Chic offers an alternative terminal UI. Collaborator reimagines the desktop as an infinite canvas; Pencil puts a design canvas in the IDE; Kata and Lovelace make project state agent-native — one as a local service, the other as repo files. Awesome Vibez documents the community building tools around agents rather than agents themselves; the infrastructure layer is where the real problems live.

Where the Sources Disagree

Speed versus comprehension. Cognitive Debt, acceleration-flow, and Slowing the Fuck Down argue unchecked speed destroys understanding; Compound Engineering counters that you do not need discipline if you have systems. Breaking the Spell of Vibe Coding goes furthest with the addiction model. The systems school is more convincing on teams, the discipline school on individuals — but the METR productivity-gap finding tilts the verdict toward the sceptics, because it shows the delusion is measurable.

Read every line versus do not read the code. Addy Osmani's Workflow, How to Effectively Write Quality Code with AI, and Scaling LLMs to Larger Codebases insist on reading every line; Simon Willison — Engineering Practices That Make Coding Agents Work says the newest rung is not reading, and shifts energy into proof. Principal Drift is the most convincing synthesis: dissolve the binary into task-routed governance — route authentication, money, and destructive changes to line-by-line review, everything else to systems inspection, with the one universal rule that the authoring agent can never be its only reviewer.

The harness matters versus the harness is not enough. How Claude Code Works in Large Codebases and The New Software Lifecycle put the ratio at 90% harness; Harness Engineering is not Enough replies that maintainability is not RL-trainable — a better harness cannot make a model produce code that stays changeable, because no fast oracle exists for good design. Both are right at different depths: the harness fixes configuration and context, but not the quality of the code it produces, and The Economic Benefit of Refactoring shows the residual is a human job.

Multi-agent orchestration versus pair programming. Agent Flywheel and ctx – Agentic Development Environment bet on fleets in isolated worktrees; Gas Town After 10,000 Hours of Claude Code rejects the delegation model for loss of visibility and git pollution; How Boris Uses Claude Code lands in the middle with parallel human-agent dialogues. The middle is the most convincing, because it keeps the verification loop human while still parallelising.

CLI versus MCP. Designing Agentic Loops and Simon Willison — Engineering Practices That Make Coding Agents Work favour shell commands; MCP Is Dead; Long Live MCP argues HTTP MCP is transformative for organisations. The split is cleanly individual-versus-organisation, and the MCP side wins at scale for the same reason harness engineering does: centralisation, auth, and observability.

Specifications as the product versus exploration as the method. How to Write a Good Spec for Agents, Structured-Prompt-Driven Development, Specsmaxxing, and OpenSpec treat the spec as durable; Code Field, Simplicity in the Age of AI-Assisted, and RepoMirror argue over-specification produces bloat and the unlock is discovering what to remove. Compound Engineering's distinction — vibe code to discover what you want, spec-driven to build it — is the most convincing resolution, and The Cost YAGNI Was Never About explains why: the two modes have different prices now.

One model versus many. How Boris Uses Claude Code uses one big model; On a Year of Multi-Model Development, Inside the AI Workflows of Every's Six Engineers, and Claude Sidecar run several. The multi-model camp's evidence — different models fail differently, and cross-model review catches what single-model workflows miss — is stronger, but Boris's counter that fewer retries beat switching is right for a single well-understood task.

What's Missing

Team adoption patterns. How does a team of ten adopt agent coding, what is the onboarding sequence, what fails first? Zero Alignment names the gap, ThoughtWorks Future of Software Engineering Retreat surfaces the problem, but neither fills it.

Cost modelling. Pixo cost $2,871; Nango's integrations under $20; Agent Flywheel estimates $440–656/month. What a User Story Actually Costs in a Dark Code Factory is the first real metering and Managing AI Coding Costs at Scale the first playbook, but nobody has published a full cost model for a sustained practice: tokens per sprint, cost per feature, cost per bug found, full TCO.

Causal evidence. Writing Code vs. Shipping Code is the strongest number in the wiki, but its weak-link hypothesis is still correlational — the wiki needs experiments, not just field reports. Five Studies That Are Changing How I Think About AI in Software Engineering is a survey, not a control group.

Failure case studies. Boris does not discuss where Claude Code struggles; the Django team in A Practical Guide to Brownfield AI Development shelved their experiment in a paragraph. Dev Machine Foundry and Uber — Agentic Engineering Shift are the first honest accounts of what goes wrong at scale, but the wiki still needs post-mortems of agent-assisted projects that died.

Agent-native project management. Kata and Lovelace are two different bets — a local service versus repo files — and neither has proven the model at team scale.

The apprenticeship crisis. Probabilistic Engineering and the 24-7 Employee and The Next Two Years of Software Engineering raise it but do not answer it: if juniors lean on AI from week one and seniors review agent output, the pipeline from junior to senior breaks.

The visual gap. What Frontend Developers Still Hate — 2026 Survey documents that agents still lack eyes — the wiki has no treatment of how to verify the parts of software a model cannot see.

Also on This Theme

Compiled from 146 sources: Continuous AI (with Don Syme), A practical workflow for LLM-assisted development, Your Coding Agent Should Do AI System Engineering (Ben Burtenshaw, Hugging Face), A Practical Guide to Brownfield AI Development, Addy Osmani's Workflow, agent-pr-replay, Agentation — Visual feedback for agents, How Kenn is doing Agentic Engineering, Agentic Software Engineering: Building Trustworthy Software with Stochastic Teammates at Unprecedented Scale, Agentic Testing: Where Agents Fit in the E2E Testing Stack, Agents and Acquiring Debt, AI Agents Migrate a Site to Astro, AI as an Enterprise Operating System, AI Can't Solve It All: Here's What 120+ Frontend Developers Say They Still Hate Working On, How Anthropic runs large-scale code migrations with Claude Code, AI-Driven Development Life Cycle: Reimagining Software Engineering, AI slop starts with the codebase itself., AI Zealotry, An Honest Review of AI Programming, Automatic programming, A new era for software testing, The Archaeologist's Copilot, Automating Myself Out of Development, Building 200+ Integrations with OpenCode, Building an almost fully self-hosted sandboxed agentic software factory, Building low-level software with only coding agents, The Clanker Constitution, Does Code Cleanliness Affect Coding Agents? A Controlled Minimal-Pair Study, Code Field, I had Codex iterate on its own AGENTS.md 8 times and measured each version against real PRs, Codex-maxxing, Coding Agents & Complexity Budgets, Maybe Coding Agents Don't Need a Bigger Memory. Maybe They Need Continuity., Cognitive Debt, Collaborator, Compound Engineering, Compound Engineering Plugin, Conquering Entropy: Cultivating Trust, Claude Mania and the Oxygen of Tiny Fires (Developer Voices, James Brown), Breaking the Spell of Vibe Coding, Optimizing for Decision Points, Designing agentic loops, Eight Myths on Software Engineering and GenAI, How my dev machine built 1,111 word-processing features and forgot to add a ruler, My Agentic Coding Setup, July 2026, Don't Fear the Dark Factory, Skills — AI skills for building software factories, Five Levels from Spicy Autocomplete to the Dark Software Factory, Five studies changing how I think about AI in software engineering, From AI Studio to AI Forge, My thoughts on Gas Town after 10,000 hours of Claude Code, The Persistent Gravity of Cross Platform, Harness Engineering is not Enough: Why Software Factories Fail, HN: Don't fall into the anti-AI hype, HN: Opus 4.5 is not the normal AI agent experience that I have had thus far, HN Discussion: Pre-commit lint checks: Vibe coding's kryptonite, HN Discussion: RIP Low-Code 2014-2025, How Boris Uses Claude Code, How to effectively write quality code with AI, How to Write a Good Spec for Agents, How We Use Claude Code Today at Intercom, The Human-in-the-Loop is Tired, I don't want your PRs anymore, I Stopped Coding and Started Architecting Agents (And Why You Should Too), If AI Is Doing the Investigation, Version the Investigation, Inside the AI Workflows of Every's Six Engineers, Context Engineering Skills: Intent Layer, Don't Wait for Claude, Bram — AI-Assisted Software Development Desktop Shell, kata, Kuna: Decompiler Development in the Age of Coding Agents, Data vs Hype: How Orgs Actually Win with AI, Lean Software Production, life-system, Loop Engineering, Lovelace, Paras Chopra on interactive HTML iteration with Claude Code, Managing AI Coding Costs at Scale, Manifest-Driven Development, Matt Pocock on AI-Assisted Development — The Smart Zone and AFK Pipeline, Maybe Coding Agents Don't Need a Bigger Memory. Maybe They Need Continuity., MCP is Dead; Long Live MCP!, MinMax Skills, Minions: Stripe's One-Shot, End-to-End Coding Agents, MobileVibe — Vibe anything from anywhere, 🎉 Mounted — bitter-FS better with Claude, A Guide to Claude Code 2.0 and getting better at using coding agents, The New SDLC with Vibe Coding: From ad-hoc prompting to Agentic Engineering, The New Software Lifecycle, Nicole Forsgren on AI and Developer Productivity, On a Year of Multi-Model Assisted Development, OpenSpec, Opus 4.5 is going to change everything, Scaling LLMs to larger codebases, PAAD — Defense-in-Depth for AI-Assisted Development, Every Software Company Will Become a Dev Tools Company, Poor Man's Loop Engineering, The Pragmatic Summit, Pre-Commit Lint Checks: Vibe Coding's Kryptonite, Principal Drift in Practice, Probabilistic engineering and the 24-7 employee, Prompting Claude Fable 5.1, Introduction to recursive-mode, Refactor Legacy Code Faster with GitHub Copilot, The Economic Benefit of Refactoring, We Put a Coding Agent in a While Loop and It Shipped 6 Repos Overnight, Running an AI-Native Engineering Org, Silently Resolved Ambiguity Is Comprehension Debt of Intent, Simon Willison: Engineering practices that make coding agents work, Simplicity in the Age of AI-Assisted, Slowing Down in the Age of Coding Agents: Using AI for Deep Thinking, not Tokenmaxxing, Slowing the Fuck Down, Software 2.0: Planning and Verifying a Greenfield Project, Software Engineering at the Tipping Point, Spec-Driven Development, Spec-Driven Development Case Study: 13 Apps in 70 Days, Solo, with AI, Specsmaxxing, Techniques | StrongDM Software Factory, Structured-Prompt-Driven Development (SPDD), Talking to Transformers, Teaching the Agent Our Craft: Structured Agentic Development on a Real Codebase, Team-Wide Agentic Harness, The AI-Native SDLC Playbook, The Claude C Compiler: What It Reveals About the Future of Software, The Cost YAGNI Was Never About, The Cult Of Vibe Coding Is Insane, The Founder's Playbook: Building an AI-Native Startup, The GUS Stack — Go, Unix, SQLite, The Joy and Power of Understanding, The Mythical Agent-Month, The Next Two Years of Software Engineering, The Future of Software Engineering — Retreat Findings and Strategic Insights, Two Kinds of User Are Emerging, UBTRIPPIN Dispatches, Understand to participate, Vibe Coding as a Team Sport, waveloop: what fable left me, What a User Story Actually Costs in a Dark Code Factory, Who Does What? Team Topologies for the Agentic Platform, Why Software Factories Fail (or: harness engineering is not enough), Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools, Writing Style Guides for Better UIs, Building World-Class Engineering Teams in the Age of AI, ytx: How To Get Better AI Responses from GitHub Copilot in Seconds! — James Montemagno, Uber: Leading engineering through an agentic shift - The Pragmatic Summit, Zero Alignment Last compiled: 2026-09-12