AI Developer - Book Structure

This document describes the logical structure of AI Developer, Book 12 of The Architecture as Code Series. The book is organised into seven parts with 33 numbered chapters, moving from the developer role in question through the craft of the five developer functions, the roles across the organisation, change and adoption, regulation and ethics, and the developer as a person, to experience and conclusions, followed by the appendices.

Chapter structure

Part I: The Developer Role in Question

The part is introduced by part_i_the_developer_role_in_question.md.

Chapter	File	Title	Description
1	`01_introduction.md`	Introduction: The Developer with AI	Introduce the book on its own terms.
2	`02_what_developers_did_before.md`	What Developers Did Before: Craft, Waterfall, Agile, DevOps and Open Source	Describe how development organised itself before AI, as the baseline for Chapters 5 to 12: the craft tradition, structured programming, waterfall, agile and Extreme Programming, DevOps and 'you build it, you run it', open source and package ecosystems, platform engineering and earlier automation of code (compilers, IDEs, code completion, low-code).
3	`03_the_pressure_on_developers.md`	The Pressure on Developers: Productivity Claims, Adoption, Legacy and Accountability	Explain why the developer's role strains: adoption pressure from vendors and executives, headcount expectations, backlog and legacy, security and supply-chain demands, regulatory duty and adversaries using the same tools.
4	`04_the_developer_loop_defined.md`	The Developer Loop Defined: Five Functions, Delegation Ladder and Stewardship	The central chapter.

Part II: The Craft of Developing

The part is introduced by part_ii_the_craft_of_developing.md.

Chapter	File	Title	Description
5	`05_frame.md`	Frame: Problems, Requirements and Intent	Treat framing without AI first: understanding the problem, requirements, user research, acceptance criteria and the specification as the source of intent; spec-driven development; ambiguity as the cost.
6	`06_design.md`	Design: Architecture, Decisions and Constraints with AI	Treat design as the choice of constraints: architecture decision records, interfaces, boundaries, data and security by design; AI as design reviewer and option generator; architectural drift in AI-generated codebases [verify evidence]; the boundary to the architect, with pointers to Books 1 and 6.
7	`07_build.md`	Build: Writing Code and the Tools of the Craft	Treat building: the progression of tools from completion through chat and edit modes to agentic modes and vibe coding, mapped to Modes 0-5; what controlled studies and field experiments found (Peng et al.
8	`08_build_with_agents.md`	Build with Agents: Delegated Coding, Mandates and Sandboxes	Treat coding agents that plan, edit many files, run commands and open pull requests: mandates (`MND--DEV-`), sandboxes, credentials, tool permissions, budgets, run records and stop paths outside the agent.
9	`09_prove.md`	Prove: Review, Tests and Verification	Treat proving: code review (what it is for, evidence on its effectiveness), testing strategy, property tests, mutation testing, formal methods at the edge and static analysis; the independent test oracle; review fatigue and the volume problem when AI produces the diffs; AI as reviewer and its limits; evaluation of AI output.
10	`10_prove_security.md`	Prove Security: Secure Code, Supply Chain and the Toolchain as Attack Surface	Treat secure development with AI: what studies measured about vulnerabilities in AI-generated code [verify]; dependencies and package hallucination, secrets, licences, provenance and SBOMs (`PRV-*`); prompt injection and excessive agency in coding tools (OWASP LLM Top 10, MITRE ATLAS [verify]); the toolchain as Tier 0; SLSA and signing.
11	`11_steward_the_release.md`	Steward the Release: CI/CD, Change and Operating What You Build	Treat stewarding the release: pipelines, trunk-based development, feature flags, progressive delivery, the four key metrics and their limits, change risk, 'you build it, you run it' with AI-generated change volume; the gate that a change cannot alter; rollback and the Revert test; pointer to AI Operations (O3 Change).
12	`12_steward_the_code.md`	Steward the Code: Maintenance, Legacy Modernisation, Technical Debt and Documentation	Treat stewarding the code over years: maintenance, legacy modernisation, technical debt and documentation; evidence on churn, duplication and maintainability in AI-assisted codebases [verify GitClear, DORA, others]; COBOL and mainframe migration with AI (public cases [verify]); knowledge loss; deleting code; ownership over years.

Part III: Developer Roles Across the Organisation

The part is introduced by part_iii_developer_roles_across_the_organisation.md.

Chapter	File	Title	Description
13	`13_the_junior_developer.md`	The Junior Developer and the Apprenticeship Problem	Treat the junior developer and the apprenticeship problem: how juniors learned; what AI changes in entry-level work; what studies measured on employment of early-career developers and on skill formation with assistance [verify, e.g.
14	`14_the_senior_developer.md`	The Senior Developer, Staff and Principal Engineer	Treat the senior developer, staff and principal engineer: the senior as reviewer, mentor, technical decision-maker and keeper of context; leverage; the risk of becoming a bottleneck of review; protecting professional judgement; the pipeline of seniors.
15	`15_the_tech_lead_and_the_engineering_manager.md`	The Tech Lead and the Engineering Manager	Treat the tech lead and the engineering manager: leading development teams with AI, team agreements, review rules, metrics that do not mislead, pairing, onboarding and headcount conversations; pointer to AI Leader (Chapters 16 and 17) for the middle layer and AI Boss for people management.
16	`16_architects_platform_engineers_and_sres.md`	Architects, Platform Engineers and Site Reliability Engineers	Treat the neighbours of the developer: the architect's role changes (pointer to Book 6), the platform team's golden paths and internal developer platform as the place where AI tooling is governed, SRE and the error budget.
17	`17_testers_quality_engineers_product_owners_and_designers.md`	Testers, Quality Engineers, Product Owners and Designers	Treat the roles that shift most: testers and quality engineers (test automation, exploratory testing, quality as an independent voice), the product owner and the designer who now build prototypes; where the role boundary moves.
18	`18_developers_in_the_public_authority.md`	Developers in the Public Authority: Procurement, Public Code and Legitimacy	Treat developers in the public authority: public procurement of software and AI tools, open source and public code, accessibility (the Web Accessibility Directive, the European Accessibility Act [verify]), archives and transparency, development under public-law accountability, in-house versus supplier.
19	`19_citizen_developers_and_low_code.md`	Citizen Developers, Low-Code and the Non-Developer Who Builds	Treat citizen developers, low-code and the non-developer who builds: shadow IT, low-code and natural-language app builders, governance without prohibition, support and sunset, data protection and security; the line between prototype and production.

Part IV: Leading Change and Adoption

The part is introduced by part_iv_leading_change_and_adoption.md.

Chapter	File	Title	Description
20	`20_measuring_and_leading_ai_adoption.md`	Measuring and Leading AI Adoption in Development	Treat measuring and leading AI adoption in development: adoption programmes, licences and seats, metrics (DORA four keys, SPACE, DevEx [verify]), why acceptance rate and lines of code mislead, the productivity J-curve, experiments inside the organisation and stopping what does not work.
21	`21_team_practice_and_culture.md`	Team Practice and Culture: Pairing, Review Culture, Trust and Psychological Safety	Treat team practice and culture: working with AI as a teammate that is not one, code review culture, trust calibration, speaking up about defects, juniors' safety to ask and shadow AI.
22	`22_developers_works_councils_and_employment.md`	Developers, Works Councils and Employment: Telemetry, Rights and Intellectual Property	Treat developers, works councils and employment: information and consultation on developer tooling and telemetry (BetrVG, MBL, WOR as in earlier volumes [verify]), monitoring of developers (pointer to AI Boss and AI Leader Chapter 22), employment terms, who owns what a developer produces with AI and collective agreements.
23	`23_when_it_breaks.md`	When It Breaks: Incidents, Outages and AI-Generated Defects	Treat what happens when it breaks: post-incident practice when AI wrote or changed the code, blameless review and the Name test, analysis of AI-involved failures, verified public incidents involving automated or AI-generated change [verify, e.g.

Part V: Regulation, Ethics and Responsibility

The part is introduced by part_v_regulation_ethics_and_responsibility.md.

Chapter	File	Title	Description
24	`24_regulation_as_constraint.md`	Regulation as Constraint: AI Act, Cyber Resilience Act, Product Liability, NIS 2, DORA, GDPR	Map the instruments to the duties of developers and their organisations at article level [verify all]: AI Act Articles 4, 25, 26 and the GPAI provisions as they touch development tools; the Cyber Resilience Act (Regulation (EU) 2024/2847) for manufacturers and open-source stewards; Directive (EU) 2024/2853 on liability for defective products (software as a product); NIS 2 Article 21(2)(e) on secure development; DORA ICT risk and third-party rules; GDPR Articles 25 and 32; the Omnibus amendments.
25	`25_ethics_professional_responsibility_and_judgement.md`	Ethics, Professional Responsibility and the Developer's Judgement	Treat where law ends and judgement starts: professional codes (ACM, IEEE, national societies [verify]), refusing to build harm, dual use, accessibility and inclusion, honesty about AI provenance, bias in what is built and whistle-blowing.
26	`26_intellectual_property_open_source_and_sovereignty.md`	Intellectual Property, Open Source and Sovereignty in the Toolchain	Treat intellectual property, open source and sovereignty in the toolchain: copyright in generated code, licence contamination, the text-and-data-mining exceptions (Directive (EU) 2019/790) and the AI Act's copyright provisions [verify]; litigation as signal (public cases [verify]); open-source dependence and maintainers' load; dependence on a few model providers, exit and European alternatives; self-hosted models.

Part VI: The Developer as a Person

The part is introduced by part_vi_the_developer_as_a_person.md.

Chapter	File	Title	Description
27	`27_competences_and_developing_the_developer.md`	Competences and Developing the Developer	Treat what a developer needs now: framing, reading code, verification, delegation design, system thinking and AI literacy under Article 4; evidence of competence rather than attendance; career ladders; frameworks (SFIA, e-CF, DigComp [verify]); hiring and interviewing when AI exists.
28	`28_the_developers_own_mind.md`	The Developer's Own Mind: Craft, Flow, Cognitive Offloading and Identity	Treat the developer's own mind: what studies measured on offloading, skill atrophy, complacency and overreliance with coding assistants [verify]; flow, craft pride and loss; identity when the typing goes; stress, boredom and wellbeing; how developers keep their skill in practice (AI-off days, reading, katas).
29	`29_the_future_of_the_developer.md`	The Future of the Developer: Fewer, More or Different?	Give the outlook with labels: employment and demand, agent-heavy teams, specification as the main artefact, regulation, offshoring, open source and education.

Part VII: Experience and Conclusions

The part is introduced by part_vii_experience_and_conclusions.md.

Chapter	File	Title	Description
30	`30_case_studies_and_anti_patterns.md`	Case Studies and Anti-Patterns	Analyse verified public cases with the book's lenses (for example a code-generation tool incident, a package-hallucination or malicious-package case, a legacy modernisation with AI, a company that reversed a headcount decision, a public-sector software failure; each verified against primary reports, drop any that cannot be verified) and catalogue the anti-patterns: the acceptance-rate dashboard, the unowned agent, the generated test that proves nothing, the junior hole, the review rubber stamp, the secret in the prompt and the vibe-coded production system.
31	`31_a_year_in_development.md`	A Year in Development: Nordvik Region and Hansa Mutual	Follow named developers in the two organisations through a year, month by month: a tool rollout, a review incident, a junior's first quarter, a works-council agreement, a supply-chain scare, a legacy migration and a drill with the agent switched off.
32	`32_conclusions_for_nordvik_and_hansa.md`	Nordvik Region and Hansa Mutual: Conclusions for Two Organisations	Draw per-organisation conclusions: a 12-month plan, decisions for leadership, KPIs of the book's own claims and risks.
33	`33_conclusion.md`	Conclusion	Judge the thesis against the evidence: what is established, expected and speculation; the author's projections (labelled); five things a reader does on Monday.

Appendices and Reference

The appendices are introduced by part_appendices.md.

Item	File	Title	Description
Glossary	`34_glossary.md`	Glossary	Defines the vocabulary of the book.
Appendix A	`35_appendix_a_code_examples.md`	Appendix A: Code Examples: Delegation, Mandate, Specification, Ownership, Verification and Provenance Records	Fuller versions of the artefacts introduced in the chapters.
Appendix B	`appendix_templates_and_tools.md`	Appendix B: Templates and Tools	A directory of the templates and tools the chapters provide, with the chapter that introduces each.
References	`36_references.md`	References and Sources	Canonical bibliography
About the Author	`37_about_the_author.md`	About the Author	Background and perspective

Companion files

File	Purpose
`DISPOSITION.md`	The fixed design of the book: premise, thesis, boundaries towards the earlier volumes, red threads, identifiers and a brief for every chapter
`BOOK_BLUEPRINT.md`	Premise, thesis, audience, the brief of every chapter, the foundations it builds on, the developer functions it concerns and its status
`SERIES_FOUNDATIONS.md`	The conclusions of Books 1–11 that this book builds on, with the tables of contents of the earlier volumes for cross-references
`EXAMPLE_ORGANISATIONS.md`	Canonical profiles of Nordvik Region and Hansa Mutual, including their development profiles (the unchanged profiles of the earlier volumes are in `EXAMPLE_ORGANISATIONS_EARLIER_VOLUMES.md`)
`CHAPTER_AUTHORING_GUIDE.md`, `STYLE_GUIDE.md`, `AUTHOR_PERSONA.md`	Rules for structure, language and voice

Canonical ordering

scripts/toc_definition.py holds the table of contents and regenerates docs/book_index.json, the mkdocs.yml navigation and the chapter list in BOOK_REQUIREMENTS.md. docs/book_index.json and mkdocs.yml must agree (tests/test_book_index.py). Chapter numbers are fixed across the series; later volumes refer back to this book by chapter number.

AI Developer - Book Structure

Table of contents

Part I: The Developer Role in Question (Chapters 1–4)

Part II: The Craft of Developing (Chapters 5–12)

Part III: Developer Roles Across the Organisation (Chapters 13–19)

Part IV: Leading Change and Adoption (Chapters 20–23)

Part V: Regulation, Ethics and Responsibility (Chapters 24–26)

Part VI: The Developer as a Person (Chapters 27–29)

Part VII: Experience and Conclusions (Chapters 30–33)

Appendices