Coding Agent Development Workflows

Nick Tune · article · 2026-01-07 source ↗ Reader 🖥️

Agent Harness Architecture Decision Records Coding Agents Context Engineering Organizational Legibility Spec-Driven Development

Making an autonomous coding agent reliable enough to go from ticket to mergeable pull request requires converting as much of the surrounding process as possible into explicit, versioned, tool-agnostic artifacts — deterministic scripts, a single shared source of truth for conventions that every agent and review tool reads, and structured task templates that reject underspecified work — because agent reliability is bounded by the explicitness of what surrounds it, not by the model's capability alone; and the harder unsolved problem this creates for teams and organizations is deciding how explicit conventions must be, who owns them, and at what level (team vs. org) they should be standardized.

practical · mixed — Primarily expository/how-to (a first-person account of a specific workflow with diagrams and config snippets), shifting into argumentative territory in the 'Key challenges for teams and organizations' section where the author makes explicit claims about what AI-assisted development requires organizationally.

Structure

Part	Role
Scoping the 'task implementation' phase: the agent works autonomously from ticket-assignment to a complete, quality-passing, mergeable PR.	context / definitions
Shell scripts vs. AI commands: deterministic steps are scripted; only genuinely interpretive steps are delegated to AI, using subagents specifically to protect the main agent's context window.	evidence — design principle
The task-completion pipeline: local build/lint/test, parallel code-review and task-check subagents, PR submission, CI/CodeRabbit/SonarQube feedback loop, autonomous fix-until-mergeable.	evidence — concrete mechanism
Single source of truth for conventions: a tool-agnostic docs/ folder referenced directly by the coding agent, the local review subagent, and third-party tools (CodeRabbit's own config points at the same files); ADRs can be referenced the same way.	evidence — solves the multi-tool contradiction problem
Build-quality-in / continuous improvement: every manually-caught issue is pushed upstream into a linting rule or a documented convention so it is caught automatically next time; checks may eventually be removed once upstream quality is high enough.	evidence — operating discipline
Key challenges for teams and organizations: standards clarity, the mindset shift toward workflow/context engineering, and the org-vs-team convention boundary, resolved (tentatively) via a principles-driven middle ground.	extension / argument
Planning and task breakdown: a PRD specialist agent plus a 10-section task template that rejects incomplete tasks, because task-definition quality directly drives implementation quality.	evidence — upstream lever
Epistemic coda: explicitly personal, provisional learnings, likely to be outdated soon.	qualification

Key terms

Task Implementation
The specific phase from the moment an agent/developer starts a ticket (self-assigns, marks in-progress) until a pull request is open and ready to merge or needs feedback.
single source of truth for conventions
A set of convention/standards documents (coding standards, anti-patterns, testing, architecture overview, ADRs) stored once, not coupled to any particular AI tool, and referenced directly by every agent and third-party tool (the coding agent, the local review subagent, and CodeRabbit via its own config) so they can't give contradictory feedback.
continuous improvement mindset
Treating every manual intervention or tool-flagged issue as a signal to push detection further upstream (first try a linting rule, then fall back to a documented convention) so it is caught automatically next time rather than repeatedly caught by hand.

Propositions

explicitThe task-implementation phase should be scoped so the agent works autonomously from ticket assignment through to a complete, quality-passing, mergeable pull request, surfacing to the human only when finished or genuinely blocked.conf: high
explicitDeterministic steps (e.g. creating a feature branch, marking a ticket in-progress) should be implemented as plain bash scripts rather than AI prompts; only steps that genuinely require interpretation should be delegated to an AI command or subagent.conf: high
explicitSubagents are used specifically to protect the main agent's context window — giving a focused sub-task fresh context that's more likely to follow instructions, and avoiding polluting the main session — not for any other reason.conf: high
explicitA multi-stage task-completion pipeline (local build/lint/test, then parallel code-review and task-requirements-check subagents, then PR submission, then watching CI/CodeRabbit/SonarQube feedback) with the agent empowered to autonomously keep fixing until the PR is mergeable, is more reliable than relying on a single pass or on human intervention at each stage.conf: high
supportsPresentation: The Agent Harness: Control Planes, Invariants, and Approval Boundaries for Production AI Agents · p14 — Tune's hand-built verify→review→check→submit→autonomous-fix pipeline is an independent, practitioner-built instance of the same event→session→lane→throttle→tools→audit-trail harness blueprint, arrived at from a coding-agent angle rather than a production-agent-reliability angle.
explicitMultiple AI agents and tools reviewing the same code must be aligned to one shared, tool-agnostic source of truth for conventions (a docs/ folder referenced directly by each tool's own config, including third-party tools like CodeRabbit), or they produce contradictory feedback that wastes time going in circles.conf: high
supportsEncoding Team Standards · p2 — Both independently converge on the same fix: team conventions must be encoded as versioned, repository-resident artifacts that execute (or are directly referenced) rather than living as separate wiki documentation per tool.
explicitThe continuous-improvement discipline is to treat every manually-caught issue as a prompt to push detection further upstream — first try encoding it as a linting rule, and if that's not possible, add it to the coding conventions or architecture documentation so the main agent or local review catches it before it ever reaches external tools.conf: high
supportsEncoding Team Standards · p6 — Tune's practice of pushing every manual catch upstream into a linting rule or convention doc is a concrete instance of the claim that generation-time application of a standard has the most leverage, because it prevents the issue before it occurs rather than catching it at review time.
explicitAs local (agent-plus-local-review) quality improves, some of today's checks may become removable, because the earlier-stage process already produces spec-conformant quality — implying the pipeline's current heaviness reflects today's uncertainty about agent reliability rather than a permanent requirement.conf: high
explicitAI-assisted development workflows work best when teams have explicit standards and clear guidelines; teams with substantial implicit/tacit conventions, or whose members hold divergent principles, will struggle more with this approach than teams that have already made their conventions explicit.conf: high
explicitA central mindset shift for engineers is that the job increasingly means workflow and context engineering rather than writing a given line of code — the goal shifts to improving the process so that line never needs to be manually written again.conf: high
supportsGit real: AI agents aren’t just for solo developers anymore · p2 — Tune's claim that engineering is becoming workflow-plus-context engineering is the individual-practitioner mirror of the claim that coding-agent product differentiation has moved off the model and onto the harness/workflow/approval layer.
explicitDeciding which conventions should be standardized organization-wide versus left to team discretion is a genuine, unresolved tension; a workable middle ground is to standardize at the level of principles (e.g. 'every team must have documented coding standards and ADRs accessible to AI agents and review tools') while letting each team choose its own concrete standards and tooling to satisfy that principle.conf: high
extendsEncoding Team Standards · p7 — Tune's principles-driven org-vs-team resolution gives a concrete answer to exactly the calibration question the other article leaves open — at what level and under what signal a team should adopt this degree of explicit standardization.
explicitTask-definition quality directly and significantly determines implementation quality; a structured task template (a fixed 10-section format covering deliverable, context, PRD traceability, acceptance criteria, edge cases, implementation guidelines, testing strategy, and verification commands) that rejects incomplete tasks forces the clarity the implementing agent needs before work starts.conf: high
implicitThe entire pipeline is an attempt to externalize and encode judgment that used to live only in a developer's head — explicit gates, conventions, and templates substitute for the tacit, moment-to-moment judgment a human author would otherwise apply.conf: medium

Arguments

Reliable, high-quality autonomous coding-agent work requires converting as much of the surrounding process as possible into explicit, versioned, tool-agnostic artifacts (scripts, shared conventions, structured task templates, layered quality gates) rather than relying on the agent's judgment alone or on ad hoc human intervention after the fact. strength: medium

Explicit premises:

Deterministic steps should be scripted, not left to AI interpretation.
Multiple review tools must share one source of truth or they produce contradictory, time-wasting feedback.
Every manual catch should be converted into a rule or doc update so it's caught automatically next time.
Task-definition quality determines implementation quality, so a structured, reject-if-incomplete template is used before implementation begins.

Implicit premises:

An agent's reliability is bounded primarily by the explicitness and consistency of what surrounds it (context, conventions, gates), not primarily by the underlying model's raw capability.
Organizations that already have clear, explicit, consistently-applied conventions are structurally better positioned for this workflow than organizations whose standards are tacit or person-dependent.

Inferences:

Because this approach requires making tacit team knowledge explicit, teams for whom that was already hard (inconsistent conventions, person-dependent judgment) face a harder transition than their nominal tooling readiness would suggest.
The organizational challenge of agent-based development is substantially an exercise in making existing-but-unwritten team knowledge legible, not purely a technical/tooling problem.

Narratives

A code-review bot leaving a PR comment that explains an implementation doesn't align with a specific, named ADR.
→ Supports the claim that the single-source-of-truth principle extends usefully to architectural decisions (ADRs), not just style/pattern conventions — a concrete instance of the fix working as intended.

Questions addressed

✅ How do you make an autonomous coding agent's output predictable and standards-compliant rather than erratic?
Scripted determinism for mechanical steps, a shared tool-agnostic conventions source for interpretive judgment, a structured task template upstream, and a layered quality-gate pipeline downstream.
⭕ Should quality checks happen locally (agent + subagent review), in CI/third-party tools (CodeRabbit, SonarQube), or both?
Currently both, as a deliberate belt-and-braces choice; the author explicitly floats removing some checks later but hasn't done so.
⭕ Who authors, maintains, and arbitrates the single-source-of-truth conventions once more than one person (a team, not a solo developer) has a stake in them, and what happens when team members disagree?

Gaps

incompleteEverything described is a single developer's personal-project workflow. The piece explicitly pivots to 'challenges for teams and organizations' but never addresses genuine multi-developer coordination — concurrent agents working on related or overlapping tickets, ownership conflicts over shared files, or how the 'single source of truth' docs get authored, updated, and arbitrated once more than one person has a stake in them.
Read next: extract-git-real-team-coding-agents.json addresses exactly this team-scale coordination problem (shared memory across agents, too-many-PRs coordination failure, management/control problem types) that this personal-scale account doesn't reach.
incompleteNo accounting is given of the autonomous fix-loop's actual success rate, time cost, or compute cost — how often it resolves cleanly versus gets stuck, or whether the time saved by autonomy exceeds the time spent building and maintaining the pipeline itself.
Read next: extract-dora-2025-state-of-ai-assisted-software-development.json and extract-five-studies-ai-software-engineering.json provide more quantified, if still imperfect, evidence on throughput/stability trade-offs that this piece's anecdotal account doesn't attempt.
uninformedThe piece never engages security, compliance, or audit-trail requirements for the autonomous pipeline — who is accountable when the agent's autonomous fix-loop makes a change that passes all automated gates but is substantively wrong, and whether 'green and ready for review' review is itself adequate given how little a human reviewer may actually re-verify once a PR already shows all-green checks.
Read next: extract-agentic-ai-and-code-reviews.json's risk-tiered, durable-audit-trail framing and extract-four-eyes-without-pull-requests.json's compliance-control framing both treat this as a central design question this workflow leaves open.

Closes gaps elsewhere

Encoding Team Standards · g2 — Tune's single-source-of-truth fix (pointing every agent's and tool's own config, including a third-party tool like CodeRabbit, at the same shared convention/ADR files) directly resolves the 'instructions conflicting across tools' half of this gap with a concrete, working mechanism — though it does not address the gap's other half, the self-conflict risk as a library of many small instructions grows.