Further Reading

ReAct: Synergizing Reasoning and Acting in Language Models

The seminal paper that introduced the paradigm of interleaving reasoning traces ("thoughts") and task-oriented actions ("actions" and "observations") for LLMs. ReAct demonstrates that synergistically coupling reasoning and acting improves agent performance, mitigates hallucinations, and increases decision-making interpretability. In the ASDLC, we position ReAct as the prompt-level execution engine of the OODA Loop, and as the inner-loop prompting primitive that is wrapped by the outer-loop persistence mechanics of the Ralph Loop. We have integrated it as a core concept under the ReAct Pattern.

Spec-Driven Development: How to Build Real Software with AI Coding Agents

Bhaskar S outlines a 6-phase Spec-Driven Development (SDD) lifecycle (Constitution → Specify → Plan → Tasks → Build → Review) designed to prevent "Context Collapse" when guiding AI agents through complex feature creation. The article maps well to ASDLC concepts, but its linear phase progression underplays the iterative refinement model of the ASDLC Learning Loop. The post also highlights three tooling paradigms: BMad-Method (persona-based), GitHub spec-kit (CLI-based), and OpenSpec (CI/schema-validated specifications). We log this post as evidence of industry convergence on SDD vocabulary and have integrated BMad-Method and OpenSpec as references on the Spec-Driven Development page.

Theory of LLM Constraints

Ljunggren reframes the LLM productivity paradox in the language of Goldratt's Theory of Constraints: localized coding acceleration (~30%, per Thoughtworks) yields only marginal net delivery improvement (~8%) because the bottleneck shifts downstream. Faros AI telemetry across 10,000+ developers reports 98% more PRs merged and 91% longer review wait times; DORA 2025 publishes the first official benchmarks for Deployment Rework Rate as the quality-leakage counterpart to PR Cycle Time. The article grounds the ASDLC bottleneck-shift thesis in named theory and empirical evidence; the ASDLC position adapts Ljunggren's prescriptive "Scaffolding-First" remediation into a Minimal Scaffolding-First stance — starting from a sensible minimal scaffold, but strictly avoiding overt scaffolding beyond that baseline unless gates earn their place by protecting against identified risks. See Theory of LLM Constraints for the dialectic.

You Need AI That Reduces Your Maintenance Costs

James Shore presents a mathematical model of software maintainability in the AI era. He demonstrates that if coding agents double output but the code's maintenance cost per line remains constant, initial productivity gains are completely erased in 19 months. Crucially, the post warns of the "lock-in" effect where removing the AI tool removes the speed boost but permanently saddles the team with the increased maintenance overhead. Shore concludes that AI must reduce maintenance costs proportionally to its speed multiplier (e.g. double speed requires halving maintenance per LOC). We log this as qualitative Agile/XP consensus supporting the Triple Debt Model and AI Amplification concepts.

Agentheim: Domain-Driven Agentic Harness

A Claude Code plugin packaging four skills (Brainstorm, Model, Work, Research) over DDD bounded contexts (.agentheim/contexts/<bc>/). A non-generative orchestrator delegates tasks to parallel workers; every SUCCESS passes through a verifier before commit. It is a concrete reference implementation of several ASDLC primitives — Generator/Judge separation from Adversarial Code Review, the Initializer + Sub-Agents shape from Ralph Loop §6 Map-Reduce, and one-task-one-commit from Micro-Commits. Agentheim reports 100% vs 54.8% on its internal reference benchmark; methodology is not published, so treat the number as anecdotal.

Linux Kernel: AI Coding Assistants Policy

The world's largest open-source project formalizes AI governance at the commit level. The policy establishes a level-invariant principle: individual commits may carry Assisted-by tags attributing AI involvement, but only a human can add Signed-off-by to certify the program increment. This distinction — agent-authored atoms vs. human-owned increments — validates the ASDLC position that Provenance requires human accountability at the merge boundary regardless of autonomy level. It also provides a concrete attribution format for Micro-Commits in agentic workflows.

Software Civil Engineering: From Craft to Discipline

Proposes the civil engineering parallel for agentic software production. It argues that modern software development requires formal specification layers (behavioral, operational, and policy), declarative product lifecycles, and a clear distinction between the "logistic layer" of agents and the material constraints they operate within. This serves as foundational validation for the ASDLC industrial thesis and introduces a needed "material science" layer to agentic architecture.

Built by agents, tested by agents, trusted by whom?

A legal and regulatory critique of the "Dark Factory" non-interactive software development model. It highlights that traditional software accountability mechanisms—product liability, professional licensing, and algorithmic audits—break down when human code review is entirely eliminated. It introduces the critical concepts of the Liability Gap, Disclosure Gap, and Contractual Gap inherent in sustained L4 Autonomy operations.

The Agentic Software Factory

An empirical case study detailing a multi-agent factory building security features into an enterprise identity server. It provides structural validation for Adversarial Code Review by using three distinct models in parallel, demonstrating that "models are better adversaries than collaborators." It also highlights the critical operational need for Identity Separation (giving distinct models their own API credentials) for auditability.

Microsoft's Agent Factory

An interview with Microsoft's EVP of Core AI that validates the shift toward an Agent Factory model. Parikh notes that tracking lines of AI-generated code is the wrong metric; the true industrial goal is eliminating "run the business" technical debt to free humans for creative architecture. He also underscores the limitations of one-dimensional evaluations versus empirical, multi-dimensional "lived experience" in tracking agent value.

Software Factories and the Agentic Moment

Provides a look into a "Dark Factory" where AI teams build software without any human code review. It details replacing boolean test success with Probabilistic Satisfaction across thousands of Holdout Scenarios, enabled by Digital Twins of external services. This serves as critical validation for how an AI Software Factory can safely operate at L4 Autonomy without drifting.

"Because much of the software we grow itself has an agentic component, we transitioned from boolean definitions of success (“the test suite is green”) to a probabilistic and empirical one... We use the term satisfaction to quantify this validation: of all the observed trajectories through all the scenarios, what fraction of them likely satisfy the user?"

Spec-Driven Development / Shifting Responsibility

Provides a profound human-centric critique of naive "spec-as-source" development. It highlights that separating engineers from implementation details leads to a degraded mental model ("Context Rot") and removes the inherent "joy of engineering." This serves as strong qualitative validation for the ASDLC spec-anchored philosophy—specs provide intent and boundaries, but maintaining interaction with the deterministic code is crucial for sustainable development.

"The tools can of course take in the context from the whole solution, but as that grows over time the quality of the model’s work will degrade. We see this with the context rot problem that many people are facing... there’s still so much more that you’re not realising by not actually getting into the weeds and tackling the problem yourself."

The AI Triangle: The Bottleneck Nobody Priced In

Provides excellent qualitative validation of the ASDLC's core thesis that the bottleneck in software engineering is shifting from generation to verification. It identifies that as the effort of coding goes down, the cognitive load of verification (checking architectural integrity, reviewing PRs from AI agents) goes up. This thoroughly supports our emphasis on deterministic enforcement using Context Gates.

"The bottleneck shifts from doing to checking, and checking doesn’t get faster just because the doing did."

Is software engineering still a craft?

Explores the human impact of the shift from craft-based development to industrial-scale agentic production. It acts as qualitative validation of the ASDLC "industrialization" thesis, mirroring the assertion that AI creates a "factory production line" feeling versus a traditional "craft." It explicitly warns against vibe-coding production systems and emphasizes that rigorous engineering practices still apply.

Boris Cherny: Plan-and-Iterate Discipline

Advocates for a disciplined AI workflow: Ask the model to generate a plan first, implement in small iterative steps, and write by hand where you have strong technical opinions. This closely mirrors ASDLC's Spec-Driven Development and Context Gates.

"Speed is seductive. Maintainability is survival."

Matt Watson: Product Thinking as Core Competency

Argues that "vibe coders" outperform average engineers because they focus on product outcomes, not just implementation. In an AI world where "just build this" work is automated, human engineers must decide what matters.

"For years, we rewarded engineers for staying in their lane, closing tickets, and not rocking the boat. Then we act surprised when they don't think like owners... Product thinking isn't a bonus skill anymore. In an AI world, it's the job."

Rasmus Widing: Product Requirement Prompts (PRPs)

Defines the minimum viable specification an AI agent needs to ship production-ready code in one pass: "PRD + curated codebase intelligence + agent runbook." His principles—plan before you prompt, context is everything, and scope to what the model can do reliably—mirror ASDLC's Spec-Driven Development philosophy.

Industry Data Points: The Technical Debt Warning

Various data points highlighting the risks of agentic development without discipline:

• Google (2024): Approximately 30% of code is AI-generated, leading to the first year where copy-pasted code exceeded refactored code.
• Anthropic: Claude Code adoption led to a 70% productivity increase, validating agentic power when structured properly.
• Forrester: Predicts 75% of tech leaders will face moderate-to-severe technical debt by 2026 due to speed prioritized over maintainability in AI-assisted development.