The developer stories enterprise IT leaders actually read.
Volume 342, Issue 2 · 8 articles
Build loops, not just agents: the feedback structure matters more than the individual automation.
This guide approaches the software factory concept from an engineering rather than a strategy perspective, and its organizing idea is to build loops rather than just agents.
An agent that produces output without a verification and correction path creates work downstream; a loop that generates, tests, evaluates and retries contains its own errors.
The article covers which feedback signals are reliable enough to close a loop around, and which require human judgment.
For teams adding agents to their delivery pipeline, this is the difference between throughput gain and review backlog.
Runtime behavior is the only truth when the person paged never wrote, and may never have read, the failing code.
On-call has a new shape when a large share of production code was generated rather than authored.
The engineer paged at 3am may have reviewed the change but has no mental model built from writing it, so the usual debugging shortcut of remembering intent is unavailable.
The article's conclusion is that runtime behavior becomes the only reliable truth, which raises the value of observability, structured logging and reproducible environments relative to code familiarity. It also raises uncomfortable questions about what review was actually verifying.
A guide to modernizing legacy applications using the 6 Rs, prioritization, incremental rollout, and outcome-based metrics.
This guide explains that legacy systems constrain businesses long before they fail, through scarce skills, rigid interfaces, and technical debt that slow releases and raise costs.
It outlines the 6 Rs of modernization (rehost, replatform, refactor, rearchitect, rebuild, and replace) and advises prioritizing applications by business value and technical risk. Success depends on mapping dependencies, clear ownership, incremental moves such as the strangler fig pattern, and rollback planning rather than big-bang cutovers.
It warns against modernizing for its own sake and suggests measuring outcomes like faster releases and quicker incident recovery.
Coding agent loops need command-based exit checks and protected tests, not model self-grading, to prevent AI slop.
The author argues that AI coding loops such as Codex and Claude Code /goal commands typically let a model decide when work is done, which leads to premature victory, empty tests, and suppressed linter warnings.
Citing SlopCodeBench, where about three in four agents made code messier over iterations, and METR research showing developers misjudge AI speedups, the piece says 'it works' is not enough.
It recommends making the exit condition a real command: formatters, type checkers, behavior-asserting regression tests, security checks, and mutation testing. Crucially, the agent must be locked out of changing those quality checks.
As AI generates more code than teams can read, review is splitting into AI-assisted, risk-based and schema-focused modes.
Code review practice is changing as AI generates more code than developers can track manually. The article covers the approaches teams are adopting: AI-assisted review that summarizes and flags rather than replacing human judgment, risk-based triage that routes changes by blast radius, and schema-focused review that concentrates attention on interfaces and data contracts where errors propagate.
It also returns to first principles about what code review is actually for, distinguishing defect detection from knowledge sharing and design feedback, which pull in different directions once volume rises.
A single prescribed AI-native development process fails; route changes by risk using state machines and external facts.
Anthropic's AI-Native SDLC Playbook correctly identifies that code is no longer the bottleneck when agents generate implementations quickly, but the author argues that one prescribed process cannot fit real organizations.
The proposal is to define processes as state machines whose transitions depend on facts drawn from external systems rather than an agent's self-reported status. Change classification should route work by risk rather than by author preference, so a config tweak and a schema migration follow different gates.
Changes to the process definitions themselves should also pass through gated review. The result preserves human judgment where it matters while letting agent-powered throughput scale.
A case for shifting from product-centric autonomous teams toward value centers with coherent organizational purpose.
The article revisits the autonomous team concept that has dominated software organization design for a decade, arguing that product-centric autonomy produces local optimization at the expense of organizational coherence.
The alternative proposed is value-center thinking, where teams hold agency over an outcome rather than a component, which changes both boundaries and accountability.
It is a useful counterweight for organizations that adopted team topologies patterns and then found coordination costs rising rather than falling. The discussion of where autonomy genuinely helps is more nuanced than the usual framing.
Octopus Deploy's John Bristowe and Viktor Farcic debate whether policy-driven pipelines can replace human review of AI code.
The New Stack previews a September 29 live debate on handling the flood of AI-generated code.
Citing data that 90% of developers use AI, pull requests are up 98%, bugs per developer are up 54%, and incidents per pull request have climbed 243%, it argues code review has become a bottleneck.
Octopus Deploy's John Bristowe says review is now 'theater' and advocates moving quality gates into delivery pipelines via policy-as-code, while DevOps Toolkit's Viktor Farcic will press on whether that can absorb human judgment. The session will also cover the impact on junior engineers.
More from Developer · All IT section newsletters · This week