Agent Planning Artifacts

Structured plans, issues and contracts produced before agents implement — vertical slices, DAG backlogs, negotiated definitions of done — so autonomous work stays coherent.

Also known as: plan cards, planning artifacts, TODO-driven planning, planner, tracer bullet / vertical slice, vertical slice, tracer bullet, agent-ready issue / independently grabbable issue, agent-ready issue, sprint contract, design tree (Brooks)

How authors use it

Oldest first (extraction date when no publication date is known).

Documents (13)

• Guillaume Barrois' Post Guillaume Barrois · 2026-10-08 source ↗ Reader 🖥️
  Building features at the speed coding agents enable creates 'cognitive debt' — an accumulating gap between what has been built and what the engineer still understands — which, like technical debt, must be deliberately repaid (through upfront planning, disposable prototyping, and PR-based review) or it will erode confidence and slow you down.
• The Work Behind Delegation: A Framework for Supervising AI Coding Agents Yeon Su Park; Nadia Arvi; Hae Ri Lee; Sehoon Lim; Qianou Ma; Juho Kim · 2026-09-22 Reader 🖥️
  Developer supervision of AI coding agents is not a single activity performed at fixed checkpoints but a connected process organized into seven distinct, loop-connected stages (Plan, Monitor, Wait, Review, Teach, Manual Fix, Update Assets) -- a reconfiguration of Sheridan's classical five-stage human-supervisory-control framework made necessary by agents' greater autonomy -- and developers manage the resulting cross-stage demands (alignment, quality, understanding) by concentrating effort in planning, distributing supervisory work to other agents and automated hooks, and externalizing recurring corrections into reusable assets.
• Inside a Software Factory Paul Iusztin · 2026-09-04 Reader 🖥️
  A 'software factory' — a human-operated automated pipeline of eight SDLC stages over a shared context layer — is the right unit of analysis for disciplined AI-assisted development because it locates humans precisely at brainstorming, planning, and final review while agents execute everything between, and the engineering skill lies not in maximizing automation but in calibrating how much of the factory to build, buy, or leave manual as team scale and trust in the plan grow.
• mattpocock/skills v1.1: does /wayfinder beat grill-with-docs? Matt Pocock (AI Hero) · 2026-07-08 source ↗ Reader 🖥️
  Pocock announces that v1.1 of his Claude Code skills repo now composes a complete agentic coding lifecycle (Grill -> Spec -> Tickets -> Implement -> Code Review), whose headline addition, /wayfinder, decomposes a plan too big for one session into agent-sized chunks mapped as GitHub issues with blocking edges so the work can be parallelized.
• New Skills! v1.1 brings /wayfinder, /research, /implement, /to-spec, /to-tickets Matt Pocock · 2026-07-08 source ↗ Reader 🖥️
  Agent-assisted software work is best handled not as ad-hoc prompting but as an explicit, skill-mediated development lifecycle — interactively grill the human into a spec, split the spec into tickets each scoped to a single agent session, implement, then code-review for refactoring smells — fronted by a dedicated planning phase (Wayfinder) that externalizes large, foggy plans onto the shared issue tracker so they survive beyond any one context window, with research, prototyping and TDD as first-class supporting stages.
• How I Use Agents Without Stopping My Own Growth Jared Currie · 2026-05-27 source ↗ Reader 🖥️
  Agentic coding tools are safe to lean on only if the developer deliberately keeps exercising the judgment they would otherwise outsource — by planning before delegating and reviewing generated code as if reconstructing its reasoning themselves — because the tools amplify whichever posture the developer brings to them.
• GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. https://github.com/Doorman11991/ · 2026-05-21 source ↗ Reader 🖥️
  A well-engineered harness — context budgeting, forgiving tool-call parsing, patch-first editing, two-stage tool routing, decomposed planning, and per-model profiles — can extract production-grade agentic coding work from small (7B-20B), locally-hosted LLMs that would otherwise be considered too weak for the task, making local, private, frontier-free coding agents viable.
• [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero AI Engineer (channel); speaker: Matt Pocock (AI Hero) · 2026-04-24 source ↗ Reader 🖥️
  AI is not a new paradigm for software engineering — the fundamentals that make working with humans effective (small tasks, vertical slices, deep modules, fast feedback loops, alignment through dialogue, TDD) are exactly what make working with AI agents effective; the path from idea to shipped feature is therefore a deliberately planned, human-driven pipeline (align → PRD → vertical-slice Kanban → AFK implementation → QA) in which the codebase itself is treated as the battleground, not the spec.
• It Ain't Broke: Why Software Fundamentals Matter More Than Ever Matt Pocock (AI Hero conference talk, AI Engineer) · 2026-04-23 Reader 🖥️
  Because AI amplifies the cost of bad code through software entropy, investing in software design fundamentals — shared understanding, ubiquitous language, deep modules, TDD, and deliberate architecture — matters more in the AI era than it ever did before.
• Jacob Langvad Nilsson's Post Jacob Langvad Nilsson · 2026-04-20 source ↗ Reader 🖥️
  Effective use of AI coding agents depends not on better prompting but on providing structured context — plans, specs, skills, hooks, and a clear understanding of the agentic loop — which is the real unlock for productive human-AI collaboration in software development.
• Harness design for long-running application development anthropic.com · 2026-03-24 Reader 🖥️
  Harness design for long-running autonomous coding should be approached as a moving target: build a multi-agent architecture (planner, generator, evaluator) that compensates for the current model's specific weaknesses on long-horizon, subjective-judgment tasks, then aggressively strip components as model capability advances — because every harness component encodes an assumption about what the model can't do alone, and those assumptions go stale.
• How I write software with LLMs stavros.io · 2026-03-09 source ↗ Reader 🖥️
  A solo practitioner can now sustain multi-week, tens-of-thousands-of-line AI-written software projects at a lower defect rate than hand-writing, but only by replacing 'ask one model to do everything' with a fixed division of labor across models (a strong model as architect doing interactive up-front design, a cheaper model as developer doing strict implementation, and one-to-three structurally independent models as reviewers) plus explicit human approval gates -- and only on technology the human already understands well enough to catch bad architectural decisions before the agent compounds them.
• How Anthropic Teams Use Claude Code Anthropic · 2025-06-03 Reader 🖥️
  Across nine internal teams spanning both engineering (Security, Inference, RL Engineering, the Claude Code team itself) and non-engineering functions (Legal, Growth Marketing, Product Design, Finance via Data Infrastructure), Claude Code's value comes less from writing application code per se than from acting as a general-purpose interface to unfamiliar systems, documentation, and workflows -- letting people without coding backgrounds independently build and run working software, and letting engineers extend their reach into unfamiliar domains -- provided teams invest in persistent context files, checkpoint-heavy supervision, and an explicit sense of which tasks warrant autonomous versus closely-supervised execution.

Propositions touching this concept (3)

By publication month, oldest first (extraction month when no publication date is known).

2026-03

• explicitPlanner agents should specify product context and high-level technical design but NOT granular technical details, because spec errors cascade downstream.
  Harness design for long-running application development · p9

2026-09

• explicitPlanning artifacts (PORTING.md mapping Zig-to-Rust patterns, LIFETIMES.tsv documenting struct-field lifetimes) were key success factors — the planning phase mattered as much as execution.
  Bun Rewrites 535K Lines of Zig into Rust in Four Months, Eliminates Numerous Memory Leaks · p4
• implicitA sufficiently rigorous process-level verification loop (planning artifacts, structural implementer/reviewer separation, post-merge fuzzing and security review) can substitute for exhaustive human line-by-line review of a million lines of generated code, provided the codebase has an extensive, language-independent test suite to serve as an oracle.
  Bun Rewrites 535K Lines of Zig into Rust in Four Months, Eliminates Numerous Memory Leaks · p7

Tensions

Open gaps (35)

• incompleteTeam adoption is treated as an exercise for the reader. Pocock's answer to 'how does this work in a team?' is essentially: 'the upstream becomes team-shared, the downstream is one or two devs managing the pipeline.' He gives no story for: review queue scaling, distribution of PRD-authoring authority, who owns skills/coding-standards as a shared asset, code-review burden as a team-wide labour question, or how juniors learn craft in a workflow where most code is agent-written.
  [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero — read next: Cutler on overload and accountability culture; Beck on socio-technical change; Fearless Change for the adoption-of-practices angle in the user's hidden-layer interests.
• incompleteThe 'pre-AI books' recommendation is the closing thesis but is left underspecified. Pocock cites Pragmatic Programmer (tracer bullets), Ousterhout's Philosophy of Software Design (deep modules), Brooks's Design of Design (design concept), Fowler's Refactoring (small steps) — but does not give a reading list, nor a mapping of which insight from which book deploys at which point in the workflow. This is the load-bearing connection to the user's craft tradition and is left as a 'go buy them on Amazon.'
  [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero — read next: The user's library already covers Beck (small steps, TCR, simple design), Hickey (Simple Made Easy), Yourdon & Constantine (Structured Design), Meadows (Thinking in Systems). The mapping work is for the orchestrator to do: e.g., Pocock's 'don't bite off more than you can chew' is Fowler-on-refactoring; deep modules is Ousterhout; tracer bullets is Hunt & Thomas; design concept is Brooks. The honest gap is that Pocock does not even mention Beck — surprising given Beck's TCR is operationally close to red-green-refactor as Pocock practices it.
• incompletePocock's workflow structurally mirrors Anthropic's harness paper (planner / generator / evaluator) and Böckeler's adaptive-control framing, but he does not name them or compare. The grill-me skill is alignment; the PRD-to-Kanban is planning; the AFK Ralph loop is generation; TDD + manual QA + reviewer-Opus is evaluation. Surfacing this overlap is essential to placing his workshop in the broader 2026 AI-coding discourse.
  [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero — read next: Anthropic harness paper, Böckeler on adaptive control, Addy Osmani on agent patterns (in the user's saves) — all map onto Pocock's lifecycle with different vocabulary.
• incompletePocock conflates two definitions of 'done': (a) feature shipped with QA-imposed taste, and (b) commit produced by the Ralph loop with passing tests. The transitions between (a) and (b) — especially the merge-and-conflict-resolution at the end of multiple parallel sandbox branches — are sketched (the Sandcastle merger agent) but not interrogated for what happens when the merger itself produces semantically broken code. This is exactly where small-PR discipline matters and where he admits he doesn't have the answer.
  [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero — read next: Beck on incremental design and TCR; trunk-based development literature; the smallcode failure-mode catalog if it covers merge-stage failures.
• incompleteThe implicit premise that the developer can read agent output well enough to QA, code-review, and impose taste is enormous. Pocock states 'understanding code deeply is going to make you a much, much better developer and get more out of AI' and 'bad codebases make bad agents' — but does not address the developer who is themselves junior, distracted, or not the original architect. The workflow may be most valuable to seniors and least usable by the engineers who most need leverage.
  [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero — read next: Marcus on code quality (in user's recent saves), Beck on apprenticeship/teaching contexts, Cutler on directly-responsible-individuals and skill distribution.
• uninformedPocock specifically defers the question on conforming to security, architectural, and API-contract constraints ('I'm going to answer that in a bit') and never returns to it. For the user's organizational context (Norwegian senior leader watching governance signals), this is the highest-value question and is left unaddressed.
  [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero — read next: Security-review skill, Schneier on Security, explainable-AI requirements paper in the user's library, organisational adoption studies on AI tooling in regulated industries.
• incompleteNo engagement with cost ceilings or economic boundaries. $124-$200 per multi-hour autonomous run is presented as routine; there is no discussion of when this stops scaling (e.g. teams running this 100x/day, regulated environments with per-call cost controls, or comparison to a human contractor at equivalent output).
  Harness design for long-running application development — read next: Read pieces that treat agent-cost economics directly — Simon Willison's pricing analyses, the smallcode argument for smaller models, any IT-procurement perspective. Also: Anthropic's own enterprise pricing docs as the implicit deployment context.
• incompleteNo treatment of audit, observability, governance, or failure containment for long-running autonomous coding. The piece's implicit deployment is 'a single engineer running experiments at Anthropic Labs.' A Norwegian public-sector or regulated context would need: persistent audit trails of each agent's actions and tool calls, rollback semantics for partial builds, secret management when agents access live services, IP provenance of generated code, and human-checkpoint policies. File-based agent communication is actually well-suited to audit — but the author never makes that case.
  Harness design for long-running application development — read next: Read the EU AI Act's high-risk-system requirements, NIST AI RMF agent guidance if it exists yet, and any sober writing on agent observability stacks. Also: cross-reference Anthropic's enterprise-tier compliance docs.
• incompleteThe 'simplify when models improve' methodology assumes monotonic capability advance. It does not address the (empirically real) case where a new model has different — not strictly better — failure modes. E.g. Sonnet 4.5's context anxiety vs. Opus 4.6's regression on some niche tasks. The methodology is silent on what to do when component removal *reveals* a new weakness rather than confirming an old strength.
  Harness design for long-running application development — read next: Look for empirical model-version-comparison work — Aider/SWE-bench longitudinal results, internal Anthropic evals if available, and practitioner accounts of regressions (e.g. Simon Willison's lab notebooks).
• incompleteThe criteria-as-stylistic-steering observation ('museum quality' produces visual convergence) is surfaced and then dropped. It is treated as a quirky finding rather than a serious concern about AI-generated homogenization. At scale, if many teams use Anthropic-suggested criteria, the result is a deep convergence in the look of AI-generated software.
  Harness design for long-running application development — read next: Read on cultural homogenization risk in generative AI (Naomi Klein, Ted Chiang, and design-criticism writing). Also: the 'AI slop' discourse and any empirical work on generated-design diversity.
• incompleteThe 'long-running' threshold is operationalized only through examples (3.8 to 6 hours) — never defined. A reader cannot tell whether the prescriptions apply to a 30-minute task, a multi-day task, or only to the specific case study durations. Böckeler's harness theory and the smallcode piece operate at different time scales without acknowledgment.
  Harness design for long-running application development — read next: Cross-reference extract-bockeler-harness-engineering.json (theoretical-control framing — variety reduction, feedforward, feedback sensors) which is time-scale-agnostic; the smallcode piece's smaller-task framing; and reach for any time-scale-explicit treatment of agent autonomy windows.
• uninformedThe piece is silent on the existence of a broader harness-engineering theoretical literature (Böckeler's adaptive-control framing, the smallcode engineering-instinct view) — even though Anthropic Labs is presumably aware. As a result, named phenomena are coined fresh ('context anxiety') without acknowledging or engaging with adjacent theory. This is not necessarily a mistake — it may reflect the piece's narrow Labs-experiment scope — but it does mean the reader has to do the cross-mapping work themselves.
  Harness design for long-running application development — read next: Maintain the syntopical map (already in this repo as syntopical-harness-engineering-for-ai-coding-agents.json) and treat this article as one empirical data point, not a theoretical contribution.
• incompleteThe 'spend more time planning' practice presupposes the planning skill and domain expertise to build a solid mental model upfront — the post doesn't address whether a less senior engineer, who may lack that expertise, can use the same practice to the same effect.
  Guillaume Barrois' Post — read next: Look for evidence on whether upfront-planning-as-cognitive-debt-mitigation holds across seniority levels, not just for experienced practitioners like the author.
• incompleteThe post summarizes slide decks (149 pages) that are only available as images. The textual content is a curator's frame, not the primary source material. Key details, evidence, and nuance from the actual presentations are inaccessible.
  Jacob Langvad Nilsson's Post — read next: Access the original slide decks or video recordings if available to extract the full arguments from each talk.
• incompleteThe 'data sovereignty' claim from the Velatir talk is mentioned without elaboration. Why has it become a strategic necessity specifically for AI-native fast-scaling companies?
  Jacob Langvad Nilsson's Post — read next: Investigate the original Velatir presentation for the sovereignty argument, likely related to EU data regulations and LLM provider data handling.
• incompleteThe post does not address how these practices interact with different AI coding tools beyond Claude Code. The entire meetup is Claude Code-specific, but the thesis about structure seems tool-agnostic.
  Jacob Langvad Nilsson's Post — read next: Compare with practitioner reports from GitHub Copilot, Cursor, or other AI coding tool communities to test whether the structure thesis generalizes.
• incompleteThe claim that a strong plan makes the resulting PR 'usually ready to ship as-is' is asserted without any measurement — no defect rate, revision count, or review-time comparison against PRs produced with weaker plans is given, so a reader cannot tell how much of the plan-quality effect is real versus optimistic self-report.
  Inside a Software Factory — read next: Read against extract-addy-osmani-software-factories-light-dark, whose back-pressure argument (only automate what you can cheaply and reliably verify) implies a measurable verification standard this article never applies to its own central claim; also compare extract-agent-cost-attribution's push for turn-level instrumentation as the kind of evidence that would substantiate or falsify the claim.
• incompleteThe claim that brainstorming and planning 'will remain' the human-heaviest stages 'even in a world where all the code is generated by AI' is stated as a durable structural fact, but no mechanism is given for why taste and business judgment specifically resist automation, as opposed to simply being what current-generation agents happen not to do well yet.
  Inside a Software Factory — read next: Read against extract-the-keyboard-was-never-the-bottleneck's four-level taxonomy of programming work and its own acknowledged gap (whether AI's weakness at higher-level judgment is a durable limitation or a current snapshot) to test whether 'planning stays human forever' is a reasoned claim or an extrapolation from present capability limits.
• incompleteThe announcement asserts benefits (parallelizable decomposition, better code review, fixed grilling) with no evidence, benchmark, or worked example — support is an anecdote plus a 'Watch the video ->' link. Most tellingly, the comparison the subject line promises ('does /wayfinder beat grill-with-docs?') is entirely absent from the body: 'grill-with-docs' is never defined or mentioned outside the subject line, so the head-to-head is not under-evidenced but wholly missing from the text — the clearest proof that the substance lives in the un-transcribed AI Hero video.
  mattpocock/skills v1.1: does /wayfinder beat grill-with-docs? — read next: Watch and transcribe the linked AI Hero changelog video (https://www.aihero.dev/skills/skills-changelog-v1-1-wayfinder-to-spec-to-tickets-grilling-improvements), or trial the mattpocock/skills v1.1 repo directly, to recover the actual reasoning, demos, and the /wayfinder vs grill-with-docs comparison.
• incompleteThe talk claims AI performs well in good codebases and poorly in bad ones, but provides no data or examples to substantiate this — it relies entirely on the audience's intuitive agreement.
  It Ain't Broke: Why Software Fundamentals Matter More Than Ever — read next: Look for empirical studies measuring AI coding tool performance as a function of codebase quality metrics (coupling, cohesion, test coverage).
• incompleteThe talk does not address who is responsible for the initial codebase quality when starting a greenfield AI-assisted project. If the AI generates the initial code, the entropy problem exists from day one.
  It Ain't Broke: Why Software Fundamentals Matter More Than Ever — read next: Investigate AI-assisted bootstrapping practices and whether initial architecture prompting can produce deep-module structures from the start.
• incompleteThe 'Improve Codebase Architecture' skill is mentioned but described only as 'quite complicated' — the talk does not explain how to refactor a shallow-module codebase into deep modules, which is the hardest step.
  It Ain't Broke: Why Software Fundamentals Matter More Than Ever — read next: Read Ousterhout's A Philosophy of Software Design chapters on deep modules; explore the mattpocock/skills GitHub repo for the actual skill implementation.
• incompleteThe talk assumes TDD is applicable to all AI-generated code, but does not address domains where TDD is hard to apply (UI, data pipelines, exploratory prototyping) or where the cost of test-writing may exceed the cost of debugging.
  It Ain't Broke: Why Software Fundamentals Matter More Than Ever — read next: Look for frameworks on when TDD is cost-effective vs. when other feedback mechanisms (type checking, property testing, visual review) are better suited.
• incompleteThe talk's five tips are presented as independent failure modes, but the dependencies between them are not explored. For example, does ubiquitous language require deep modules to be effective? Does Grill Me only work if the developer already has architectural knowledge?
  It Ain't Broke: Why Software Fundamentals Matter More Than Ever — read next: Consider whether these practices form a prerequisite chain or can be adopted independently.
• incompleteThe headline '87% benchmark with 4B-active model' is the entire credibility hook and is completely unspecified in the body. No benchmark name (SWE-Bench? Aider polyglot? HumanEval? a custom suite?), no subset, no scoring methodology, no comparison baseline (what does a frontier model score on this same eval? what does the same 4B model score without SmallCode?), no link to results. For a rigorous adopter this is the single most disqualifying gap.
  GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. — read next: Check the GitHub repo itself for an evals/ or results/ directory; check the project's `/eval` command output; check whether any third party has reproduced. Compare against published SWE-Bench / Aider / HumanEval+ leaderboards for similar-sized models. Look for the actual model named in the example (gemma-4-e4b) and find its baseline scores.
• incompleteNo comparison to other small-model-aware agentic coding tools — Aider (with local models), Cline + Ollama, Continue, OpenHands with local backends, Roo. The only named comparator is OpenCode, which is set up as a strawman ('assumes frontier models').
  GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. — read next: Read Aider's local-model documentation and benchmark notes (Paul Gauthier publishes Aider polyglot scores for many models). Compare with Cline's local-model guidance and OpenHands' SWE-Bench results with open models.
• incompleteOne-author ecosystem risk: SmallCode depends on BoneScript, MarrowScript, and budget-aware-mcp — all by the same GitHub user. If the author stops maintaining, four projects rot together. This single-maintainer concentration is not flagged anywhere.
  GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. — read next: Check commit history and contributor counts on all four repos; check npm download stats for smallcode and budget-aware-mcp; check whether MarrowScript / BoneScript have any external adopters.
• misinformedThe escalation target list cites 'Claude Sonnet 4.5 / 4.6, Haiku 4.5' and 'GPT-5.4 Mini / Nano' and 'DeepSeek V4 / V4 Pro / V4 Flash'. As of the document's apparent date, these specific named version numbers may be aspirational, outdated, or fabricated. The presence of confidently-named future/non-existent model versions weakens credibility on other un-checkable claims.
  GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. — read next: Cross-check the named model versions against vendor product pages; if they are not real, treat the rest of the README's confident numbers (87%, '8-15 → 1-2 tool calls', '1400+ lines from 50 lines') with proportional skepticism.
• illogicalThe marketing claim ('87% with 4B-active model') and the body text ('7B-20B local models') are inconsistent. The title advertises a 4B-active model; the body describes the project as targeting 7B-20B. If 4B-active means MoE active params with a larger total, both can be true — but the README never reconciles them, leaving the reader to guess.
  GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. — read next: Identify the actual model used to produce the headline number; if it is MoE (e.g. gemma-4-e4b with ~4B active), check whether 7B-20B framing in the body is meant as total-parameter range, active-parameter range, or both — the project's positioning depends on which.
• incompleteNo discussion of how the harness itself is engineered, tested, or evaluated. The Observability section mentions traces and `/eval` but provides no example evaluation results, no harness-coverage metrics, no failure-mode regression tests beyond 'trace-to-test'. The harness is presented as fait accompli, not as something the reader could audit.
  GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. — read next: Connect to Birgitta Böckeler's harness-engineering article (already in the user's library): her steering-loop concept asks how a team iterates the harness based on observed failures. Apply that lens here — what is SmallCode's own steering loop?
• incompleteThe cybernetic / control-theory framing latent in the design (variety reduction via BoneScript topologies, feedback via early-stop detection, model profiles as adaptive control) is never made explicit. Connecting this project to the broader harness-engineering conversation (Anthropic's effective harness paper, Böckeler's framework) would let it argue from theory rather than just engineering instinct.
  GitHub - Doorman11991/smallcode: AI coding agent optimized for small LLMs. 87% benchmark with 4B-active model. — read next: Read SmallCode against Böckeler's 'Harness engineering for coding agent users' (in this batch) — map SmallCode's components to her feedforward/feedback and computational/inferential axes. Read against the Anthropic harness-design materials the user is also tracking.
• illogicalThe article asserts a trend toward needing less human review per model generation (line -> function -> architecture, possibly disappearing next year) while simultaneously asserting that the workflow's core safety property depends on a human who deeply understands the architecture catching bad decisions before they compound. If review granularity keeps moving upward to the point of disappearing, the same logic implies the human safety net the rest of the article depends on would disappear with it -- a tension the piece never surfaces or resolves.
  How I write software with LLMs
• incompleteThe costs of the prescribed safety apparatus -- up to three reviewer models per change, an architect conversation that can run thirty minutes, and an explicit human approval gate -- are never weighed against the speed/defect-rate benefits the article narrates in detail. There is no accounting of total token spend, wall-clock time, or how the cost/benefit shifts for a less important change where the author says he uses fewer reviewers.
  How I write software with LLMs
• incompleteThe workflow-diagramming method relied on retrospective reconstruction after a single ~40-minute task, and participants were introduced to Sheridan's five-stage framework before drawing their own diagrams -- a sequencing the authors themselves flag (§9) as a possible anchoring effect on how participants segmented their own supervision, even though they were explicitly told not to follow it.
  The Work Behind Delegation: A Framework for Supervising AI Coding Agents — read next: A within- or between-subjects comparison of workflow diagrams elicited with versus without prior exposure to Sheridan's framework, to measure the anchoring effect directly rather than only naming it as a limitation.
• incompleteThe three supervisory strategies (concentrating effort in Plan, distributing work, externalizing into assets) are presented as complementary, but the paper doesn't examine whether they trade off against each other within a single developer's limited time budget -- e.g. whether time spent building and maintaining MISTAKES.md-style assets displaces time that could have gone into planning, or whether developers who delegate review heavily to other agents plan less thoroughly because they expect agent-review to catch gaps.
  The Work Behind Delegation: A Framework for Supervising AI Coding Agents — read next: A time-allocation study tracking how individual developers split effort across Plan, asset maintenance, and delegated-review configuration, to test whether the three strategies are additive or substitutive.