Developers share scoped coding-agent workflows for staged context control

• Scoped stages are replacing the one giant coding-agent run: the software factory thread breaks work into planning, implementation, and review, while the grilling note moves missing requirements and contradictions before code.
• Context control now has research backing: the progressive-disclosure summary says a flat skill lifted 20-book QA from 0.257 to 0.462, while the PRO-LONG summary reports an 18-point average ARC-AGI-3 gain from a searchable log.
• Verification is becoming a harness layer: the constraint thread surrounds agent-written code with tests, gherkin, QA procedures, quality metrics, mutation testing, and coverage.
• Generic review is losing mindshare: one review note says project standards matter more than broad review prompts, and the specialized-review note says teams get higher signal when a human reviewer teaches the agent the local style.
• Thin prompts are now the vendor line too: the Claude Code prompt note says Anthropic cut about 80% of the system prompt for newer models.

Anthropic’s context-engineering post says Claude Code shed over 80% of its system prompt for newer models. Its verification-loops post frames tests, linters, runtime errors, and manual checks as agent skill loops. The PRO-LONG paper keeps a full structured log and lets agents search it with normal coding tools; LangChain’s eval-skill launch turns repo context and traces into Harbor evals.

The clearest practitioner version is the software factory thread, which rebuilt Squid around three stages after one giant workflow made mid-feature plan changes and small fixes too expensive.

The staged shape:

1. Planning: start from a rough feature idea, then grill it for missing requirements, weak assumptions, architectural gaps, and edge cases.
2. Implementation: split the work between a Software Engineer role and a Tester role that tries to break the result.
3. Review: review the pull-request diff, not the whole repo; merge product and architecture critique into one Product Architect role.
4. After review: run CI, formatting, linting, integration tests, and regression checks; failures create a new implementation task.

The useful move is cheap: the grilling note puts contradictions and missing requirements into the plan before they become code.

The progressive-disclosure paper tested raw navigation, flat skill layouts, deeper skill layouts, and a standard retriever across long-document agent setups.

The results from the progressive-disclosure summary were narrow but practical:

• One book: strong agents already searched well, so the flat skill added almost no accuracy.
• Twenty books: English open-question accuracy rose from 0.257 with raw navigation to 0.462 with a flat skill.
• Layout depth: one routing layer preserved context better than deeper skill hierarchies.

Skills here look less like model upgrades and more like context indexes that start paying off once the library is too large to browse cleanly.

PRO-LONG takes the opposite side of the context tradeoff: keep the full record, then make retrieval programmable.

According to the PRO-LONG summary, the method stores every observation, action, result, and short plan in one structured text log. The agent then uses ordinary coding tools, including search commands and Python, to recover relevant evidence.

On 25 hidden-rule ARC-AGI-3 games, the PRO-LONG paper reports an 18-point average gain for the same base agents, while using 4.2 to 5.8 times fewer billed tokens than stronger specialized systems.

Matt Pocock’s context decision tree turned session management into five choices instead of one vague “keep going.”

The choices in the decision-tree post were:

• Continue in the current session.
• /clear.
• /handoff.
• Use a subagent.
• /compact.

Compaction timing was the sharp edge. A reply put “~150K tokens” as the smart zone and said compaction usually belongs at a phase boundary phase-boundary reply. Another reply said compacting mid-phase is “really bad,” with subagents as the split-work alternative mid-phase compaction reply.

For larger work, the spec-and-tickets reply split planning artifacts into a spec as the destination and tickets as the journey, with each ticket sized to one coding session.

Generic review is getting squeezed between background automation and local standards.

One thread argued that off-the-shelf review bots are not high-signal enough, and that review should run as a git or Claude hook that launches subagents with project-specific skills the review-bot complaint. Claude Code moved in that direction operationally: the 2.1.218 changelog changed /code-review to run as a background subagent, so review work no longer fills the main conversation.

The specialization argument showed up repeatedly:

• one review note said a generic review skill is hard because it needs curated standards for the project.
• a code-review follow-up said /code-review does a little generic review, then delegates to coding standards and spec compliance.
• the specialized-review note said the best human reviewer on the team can teach an agent how to review exactly as they do.

The most controversial thread was not about model choice. It was about replacing line-by-line reading with constraints that produce reviewable data.

The constraint stack in the constraint thread included unit tests, gherkin tests, QA procedures, quality metrics, mutation testing, test coverage, and other gates. A follow-up said the point was not trust: the agent is surrounded with constraining applications and watched “like a hawk” trust reply.

The concrete mechanics were more interesting than the slogan:

• Function size is constrained through cyclomatic complexity of 6 or below; the complexity reply says agents run crap4clj and extract functions until the threshold is met.
• Unit tests are agent-written and not manually reviewed, while gherkin acceptance tests and QA procedures get human review depending on criticality test-review reply.
• Code quality is measured with tools, not asserted by prompts, according to the code-quality reply.
• Tests are deliberately overloaded with mutation testing, QA procedures, and gherkin tests so the agent cannot satisfy one brittle check and move on the overloaded-tests reply.

The same decomposition is moving into evaluation work: traces become the raw material, humans define what matters, and agents help turn that into executable tests.

Hamel Husain’s starter loop was compact: the trace-clustering note clusters traces, builds an annotation app, and has AI monitor annotations in real time to adapt sampling and propose labels.

LangChain’s Eval Engineering Skill formalizes that flow for coding agents. the launch post says the skill builds evals from repository context and traces, while the installation note says it produces a Harbor task under evals/, runs a target, and reviews whether the verifier measured the intended behavior.

Matt Lam’s OpenBench pushed the same question across harnesses. the OpenBench launch integrated Codex, Claude, Cursor, Devin, Grok Build, and Pi, then measured correctness, input/output/cache token use, and latency.

Claude Code’s own prompt got smaller.

Anthropic’s context-engineering post says much of Claude’s context is assembled from system prompts, Skills, CLAUDE.md, memory, and other sources, not just the user prompt. It also says Anthropic found it had been overconstraining Claude Code through the system prompt, CLAUDE.md, and skills.

That matched the minimal-prompt note, which argued newer models need minimal preference text, richer context, simple tools, and guardrails. A shorter community version said the pattern is “thin skills, fat references,” with depth loaded only when needed the thin-skills note.

Paulius Zitinavicius’ own context tricks went the same direction: the context-engineering tricks used progressive disclosure references, LLM wikis, summarizing subagents, ADRs, and a glossary, while rejecting codebase graphs for his own code because code and docs can drift.

Claude Code now exposes /doctor to rightsize skills and CLAUDE.md files, according to Anthropic’s context-engineering post.