Mise en Place for Agentic Coding: Deliberate Preparation as Context Engineering Methodology Andrew Zigler 0009-0001-8073-5917 [email protected] LinearB Los Angeles, USA
arXiv:2605.05400v1 [cs.SE] 6 May 2026
Abstract The rapid adoption of AI coding agents has produced a dominant workflow pattern — often called “vibe coding” — that prioritizes speed of implementation over deliberate preparation. We argue that this approach creates a systematic alignment problem: agents that lack sufficient context produce code requiring extensive debugging and refactoring, consuming substantial development time. Drawing on the culinary concept of mise en place (everything in its place; abbreviated MEP), we propose a three-phase preparation methodology for agentic coding: (1) contextual grounding, where domain expertise and tacit knowledge are externalized into structured documents; (2) collaborative specification, where humanagent dialogue produces detailed design artifacts; and (3) task decomposition, where specifications are converted into structured, dependency-aware task records. We report on the application of MEP during a competitive hackathon, where roughly two hours of preparation enabled a rapid parallel implementation of a full-stack educational platform by concurrent AI agents. We introduce the concept of context fluency as an emerging developer skill — the ability to create rich, structured context that agents can act on — and connect it to established frameworks in backward design and tacit knowledge externalization. We conclude with a research agenda for empirically validating preparation-phase methodologies in AI-assisted software development.
that debugging misaligned agent output can consume substantial development time [10, 22]. The bottleneck in agentic coding is not code generation but alignment between developer intent and agent output—specification compliance, architectural fidelity, and low corrective-commit ratios. We argue that this alignment problem is fundamentally a preparation problem. Drawing on the culinary concept of mise en place (MEP)—a French term meaning “everything in its place”—we propose a preparation-first methodology for agentic coding. In professional kitchens, thorough preparation enables fluid execution: every ingredient is measured and every tool positioned so that once cooking begins, the chef’s hands never pause to search. The same principle applies to agent orchestration. When domain expertise, design intent, and task boundaries are externalized into structured artifacts before agents begin writing code, the resulting implementation is more aligned, more coherent, and less costly to verify. MEP formalizes this preparation into three steps: contextual grounding (tacit knowledge captured in machine-legible documents), collaborative specification (human-agent dialogue producing detailed design artifacts), and task decomposition (specifications converted into dependency-aware work records). We position MEP relative to spec-driven development, prompt engineering, and iterative AI coding in Section 2. This paper makes four contributions: (1) A three-phase MEP methodology for agentic coding, grounded in backward design [21] and tacit knowledge externalization [17]. (2) A case study applying this methodology in a competitive hackathon, with quantitative data on preparation artifacts and implementation outcomes. (3) The concept of context fluency as an emerging developer skill—the ability to create rich, structured context that AI agents can act on. (4) A research agenda with five open questions for empirical validation of preparation-phase methodologies.
CCS Concepts • Software and its engineering → Software creation and management; Collaboration in software development; • Humancentered computing → Human computer interaction (HCI).
Keywords agentic coding, mise en place, context engineering, vibe coding, context fluency
1
Introduction
AI coding agents are remarkably capable at code generation: controlled studies of GitHub Copilot report productivity gains of 21– 55% across programming tasks [15], and the broader ecosystem can now scaffold entire applications from natural-language descriptions. Yet the dominant workflow pattern—what Karpathy [11] termed “vibe coding”—prioritizes speed of implementation over deliberate preparation. The developer describes an intent, the agent produces code, and misalignments are resolved through iterative correction. This creates a systematic alignment problem: agents operating without sufficient context produce code that requires extensive rework. Veracode reports that 45% of AI-generated code contains security flaws [19], and practitioners consistently observe
2
Background and Related Work
Early empirical studies of AI-assisted coding reported substantial productivity gains: Peng et al. found that developers using GitHub Copilot completed tasks 21–55% faster [15]. However, speed has not translated cleanly into quality. Veracode’s 2025 analysis found that 45% of AI-generated code contains security flaws [19], while Mozannar et al. showed that developers’ mental models frequently diverge from actual AI behavior, leading to inappropriate acceptance of incorrect suggestions [13]. Vasconcelos et al. demonstrated that trust in AI code generation depends on context-aware explanations that current tools rarely provide [18]. Together, these findings
Prompt and Context Engineering
A substantial body of work studies how to elicit better behavior from large language models through careful instruction. Foundational results established that LLMs perform new tasks from in-context examples [3], and that intermediate reasoning steps improve task accuracy [20]. Liu et al.’s survey [12] catalogues a maturing taxonomy of prompting techniques. More recently, the discourse has shifted from prompt engineering to context engineering: designing the complete informational environment surrounding an LLM [2, 6]. Alomar et al. extend this thread with promptware engineering [1], and Dakhel et al.’s taxonomy identifies eleven distinct human-AI interaction types [4]. MEP operates at a different scope from prompt engineering: prompt engineering tunes individual model invocations, whereas MEP structures the workflow-level artifacts (specifications, decompositions, externalized tacit knowledge) that precede and constrain those invocations. Both shape what the model receives, but at different granularities.
2.2
Preparation Methodologies
Several preparation-oriented methodologies anticipate aspects of our proposal. Horthy’s Research-Plan-Implement (RPI) methodology [9] most directly approaches this work, requiring practitioners to complete discrete research and planning phases before any code is generated. MEP differs from RPI by formalizing tacit knowledge externalization in Phase 1 and insisting on backward-design sequencing where all three phases complete before implementation begins. GitHub’s Spec Kit [7] formalizes specification-driven development, where a structured specification artifact governs agent behavior throughout implementation. These contributions recognize that what happens before agent execution shapes outcomes, but none offers a unified, theoretically grounded preparation methodology that integrates tacit knowledge externalization, collaborative specification, and dependency-aware decomposition into one phasegated sequence.
2.3
Practitioner Tooling and Theoretical Grounding
A parallel stream of practitioner innovation addresses preparation through tooling. Karpathy coined “vibe coding” [11] for a minimalpreparation workflow scoped to throwaway projects, yet the term came to characterize the dominant mode of AI-assisted development. At the opposite end, Huntley’s Ralph Loop [10] provides finegrained iterative task delegation, and Yegge’s Beads framework [22] addresses agent memory through structured task records, extended by Emanuel’s Rust reimplementation [5]. These tools solve specific problems—iteration, memory, orchestration—but assume that appropriate context already exists. MEP draws on two theoretical frameworks. Wiggins and McTighe’s backward design [21] holds that effective instruction begins with desired outcomes, then works backward through assessment criteria—we apply this principle by
Execution
2.1
Validation
point to a productivity paradox: AI agents accelerate output while simultaneously increasing the surface area for rework and defects. The bottleneck in agentic coding, we argue, is not code generation but alignment—ensuring that what agents build matches what practitioners intend.
Andrew Zigler 0009-0001-8073-5917
Preparation
VibeX 2026, 9–12 June, 2026, Glasgow, Scotland, United Kingdom
Phase 1
Phase 2
Phase 3
Contextual Grounding
Collaborative Specification
Task Decomposition
Agent1
Agent2
···
Agent𝑛
Integration Verification
Figure 1: The MEP methodology. Three sequential preparation phases produce structured artifacts consumed by parallel agents. Task decomposition distributes independent work units to 𝑛 concurrent agents, whose outputs converge in integration verification. defining agent outputs and success criteria before designing context. Polanyi’s tacit knowledge—“we can know more than we can tell” [16, 17]—frames preparation as a knowledge externalization problem; Nonaka and Takeuchi’s SECI model [14] formalizes this tacit-to-explicit conversion as a repeatable organizational process, grounding Phase 1.
2.4
Positioning: What is New
The ingredients of MEP are individually well-established; our contribution is integrative and scope-specific. Against spec-driven development [7], MEP adds Phase 1 for externalizing tacit, value-laden knowledge that specifications alone do not capture. Against prompt engineering [3, 12, 20], MEP operates at workflow rather than invocation scope. Against iterative or vibe-coding workflows [10, 11], MEP front-loads alignment work that iterative flows pay incrementally as rework. Agentic workflows need this preparation because agents lack the tacit context human collaborators carry and cannot iterate cheaply without expensive re-generation.
3
The Mise en Place Methodology
We propose mise en place (MEP) as a structured preparation methodology for agentic coding. We observe in AI-assisted software development the same dynamic that governs professional kitchens: practitioners who invest in deliberate preparation—externalizing domain knowledge, producing detailed specifications, and decomposing work into structured task records—execute faster, with more alignment, and require less corrective iteration. MEP formalizes preparation into three sequential phases, each producing artifacts that feed the next. Inspired by backward design [21], the phases are completed before implementation begins. Figure 1 illustrates the phases and their relationship to agent execution.
3.1
Phase 1: Contextual Grounding
The first phase externalizes domain expertise and tacit knowledge into structured documents agents can consume—what Polanyi [17] called tacit knowledge, the understanding practitioners possess but struggle to articulate. The artifacts are briefing documents
Mise en Place for Agentic Coding: Deliberate Preparation as Context Engineering Methodology
(markdown files encoding domain knowledge, competitive analysis, design philosophy) that force the practitioner to articulate implicit knowledge and create a persistent context layer agents reference throughout implementation. Following backward design [21], contextual grounding begins with outcomes rather than features.
3.2
3.3
Phase 3: Task Decomposition
The final preparatory phase converts the specification into structured, dependency-aware task records. We employ Beads [5, 22]— lightweight JSON records backed by Git, carrying priorities, dependencies, and acceptance criteria—though the principle generalizes. Fine-grained decomposition enables parallel agent execution without coordination overhead: when each task has clear boundaries and explicit dependencies, multiple agents work simultaneously. The coordination burden shifts from runtime to preparation time, where human judgment about system architecture is most valuable. Following parallel execution, integration verification validates outputs against the specification. The three phases draw individually on established work [9, 10, 16]; MEP’s contribution is their integration into a phase-gated process that completes before implementation begins.
4
Case Study: Competitive Hackathon
We report on the application of MEP during a competitive hackathon to illustrate the methodology’s behavior under realistic constraints. The setting imposed fixed time limits, external evaluation, and a requirement to produce working software—conditions that favor rapid iteration and penalize unproductive preparation.
4.1
Setting
The hackathon took place in January 2026, organized around a publisher’s editorial archive and an AI-powered content API. Approximately 12 teams competed in a five-hour window to build working prototypes, with judging by an industry panel and a $5,000 prize for the top project. Teams self-organized around pitches submitted before the event [8]. The practitioner-researcher had professional backgrounds in both education and software engineering, a combination that informed the product concept and design decisions throughout the event.
4.2
Table 1: Hackathon timeline, artifacts, and deployment cadence. Phases overlap inside the preparation block; agent implementation runs in parallel across four agents. The deployment-and-polish window produces nine commits at ∼5 minute mean intervals.
Phase 2: Collaborative Specification
The second phase produces detailed design artifacts through structured human-agent dialogue: the practitioner describes intent, the agent proposes details, the practitioner accepts, rejects, or modifies. The key mechanism is encoding value judgments as specification constraints—what to exclude is as important as what to include. The output is a design document specifying screens, interactions, data flows, and quality standards, capturing not just the what but the why. This rationale enables agents to make aligned micro-decisions during implementation without escalating to the practitioner.
Preparation Phase
While most teams began coding within the first fifteen minutes, the practitioner-researcher spent approximately two hours in deliberate preparation, applying the three phases described in Section 3.
VibeX 2026, 9–12 June, 2026, Glasgow, Scotland, United Kingdom
Phase
Duration
Key Artifacts / Cadence
Contextual grounding Collab. specification Task decomposition Agent implementation
∼2 hr (concurrent) (concurrent) 184 min
10 docs (9,386 words) Product specification 64 beads w/ dependencies 43 beads closed (med. 5.9 min)
Deploy: setup Deploy: gap Deploy: content fixes
22:24–22:39 22:39–22:49 22:49–23:17
5 commits, 1 every 3 min — 4 commits, 1 every 7 min
Contextual grounding produced 10 planning documents totaling 9,386 words, including API exploration notes, competitive analysis, and—critically—an extended dictation on pedagogical design philosophy drawn from the practitioner’s teaching experience, encoding tacit knowledge about how effective learning environments create conditions for student thinking [17]. Collaborative specification occurred concurrently, as the practitioner refined the product concept through dialogue with an AI agent. The resulting specification described a platform where teachers curate bounded research environments from The Atlantic’s archive and students conduct research using a Socratic AI tutor. Key value judgments encoded in the specification included constraining the product to a single assignment type (prioritizing depth over breadth for a three-minute demo), insisting on real API data rather than mocks, and scoping the analytics dashboard to show the student’s research journey rather than only the final submission. Task decomposition converted the specification into 64 structured task records with priorities and dependencies. The planningto-code ratio—9,386 words of planning against 8,496 lines of source code—was 1.10:1. Table 1 summarizes the timeline alongside the deployment commit cadence.
4.3
Implementation and Results
Four parallel subagents were deployed across distinct feature areas: classroom creation, student research workspace, day-one/daythirty demo toggle, and Socratic AI tutor. The agents drew on the contextual grounding documents and specification produced during preparation. The 64 task records served as the interface between preparation and execution (Figure 1); each bead encoded an independently executable unit with boundaries that required no inter-agent coordination. Closure timestamps confirm genuine parallelism: agents completed work simultaneously across feature areas, with a median closure time of 5.9 minutes per bead (Figure 2). The subsequent deployment phase produced 9 commits over 52 minutes. The final codebase comprised 43 TypeScript/TSX files totaling 8,496 lines, deployed to production as a full-stack educational platform. Three observations bear on evaluation. First, the architecture required no structural refactoring during deployment: the bugs that emerged were integration and styling issues (API content truncation, inter-component data flow, favicon configuration), not architectural misalignment. Second, the preparation-to-execution ratio
VibeX 2026, 9–12 June, 2026, Glasgow, Scotland, United Kingdom
Andrew Zigler 0009-0001-8073-5917
planning artifacts. Single- versus multi-agent use trended toward single-agent loops; only T12 (this study) fanned parallel subagents from a decomposed plan. Artifact production was correspondingly uneven across the two clusters. Without controlled comparison we cannot link these patterns to outcomes, but the field samples the preparation-versus-iteration spectrum motivating RQ1 and the multi-team replication study in Section 6.
median 5.9 min 10
beads closed
8 6 4 2
5
0
Effective agentic coding requires a skill set distinct from both traditional programming and prompt engineering. We propose context fluency to describe this capability: the ability to create rich, structured context that AI agents can act on. Context fluency captures domain expertise, value judgments, and design intent in machine-legible form—not as one-shot prompts, but as persistent informational environments. Prompt engineering optimizes individual instructions; context fluency is upstream of prompting, concerned with the informational architecture surrounding agent execution [2, 6]. Where MEP describes a sequence of phases producing artifacts, context fluency describes the practitioner skill that makes the process effective. We identify four components of context fluency:
min 0
5
10 15 20 25 30
Figure 2: Per-bead completion time distribution across the 43 closed hackathon beads. Most work units complete inside a single 10-minute agent session; long-tail outliers correspond to API-client and state-persistence tasks executed in parallel with shorter decomposed work. Table 2: Twelve-team field at the hackathon, grouped by problem cluster, with workflow style as inferred from pitches and observation. Identifiers are anonymized; “vibe” denotes a self-described non-technical or iterative-prompting workflow, “decomp.” denotes explicit planning before coding, and “mixed” denotes both modes within one team. ID
Pitch theme
Cluster
Workflow
T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12
Infinite-canvas archive graph Reading-comprehension overlay In-article excerpt exploration AI “knowledge gauge” (reading level) Auto-generated event timelines Topic-following / catch-up alerts Editorial content optimization (CORE) Reader-interpretation probes Structured reader-expert input Argument-evolution interaction layer Newsroom knowledge-graph copilot Curated classroom research workspace (this study)
Discovery Education Discovery Accessibility Context Personalization Personalization Trust Trust Discovery Productivity Education
decomp. vibe mixed vibe vibe mixed decomp. decomp. decomp. decomp. decomp. decomp.
was approximately 5.7:1 (two hours of preparation against ∼21 minutes of active implementation per agent across four parallel agents). Bug-type beads resolved at a median 1.2 minutes (mean 1.5 min) versus 9.7 minutes for implementation tasks, suggesting parallelexecution defects were detected and corrected quickly. Third, nearzero architectural rework is consistent with the hypothesis that rich upfront context reduces agent misalignment, though we cannot establish causation from a single case study.
4.4
Variation Across Teams
The 12-team field offers a qualitative sketch of how peers approached the same constraints. We did not instrument other teams; identities are anonymized and observations are coarse-grained, drawing on publicly shared pitches and event observation. Table 2 groups pitches into thematic clusters with each team’s described workflow style. Three patterns emerge. Workflow style split roughly in half: vibe-coding pitches (T2, T4, T5) leaned on iterative prompting, while engineering-led teams (T1, T7–T12) opened with explicit
Context Fluency: An Emerging Skill
Decomposition: Breaking problems into discrete, parallelizable tasks with clear boundaries, enabling concurrent agent execution. Specification: Describing not just what to build but why, so agents can make aligned micro-decisions without human intervention. Constraint definition: Knowing what to exclude, simplify, or defer—scope management as a first-class concern. Domain encoding: Externalizing tacit knowledge [17] that agents cannot generate on their own—directly instantiating what Nonaka and Takeuchi [14] term externalization, converting tacit knowledge into explicit, communicable form. Twenty minutes of dictated pedagogical intuitions produced context that substantially reduced iteration on the domainspecific tutor component. These components map to established frameworks. Backward design [21] contributes outcome-driven preparation; Polanyi’s tacit knowledge [16] frames the externalization challenge—“we know more than we can tell,” and context fluency is the discipline of telling it anyway. Context fluency also resembles pedagogical scaffolding: structuring an environment so the learner (or agent) can act independently. If context fluency is a distinct skill, the implications extend beyond individual practice. For developer education, curricula should cultivate specification, decomposition, and domain-encoding alongside programming competencies. For hiring, practitioners with strong domain knowledge and pedagogical instincts may be disproportionately effective in agentic workflows [4]. For tool design, preparation aids—task systems [5, 22], specification frameworks [7], and context engineering platforms [2]—are essential infrastructure, not optional enhancements.
Mise en Place for Agentic Coding: Deliberate Preparation as Context Engineering Methodology
6
Limitations, Research Agenda, and Conclusion 6.1 Limitations The empirical claims rest on a single hackathon, a single practitioner, and no control group. (i) Single hackathon, single case study. Findings are illustrative, not generalizable; a five-hour competitive setting is not multi-month software development. (ii) No control group, no iteration-first comparison. We did not run a paired condition without preparation, nor instrument the other 11 teams; the 5.7:1 ratio and near-zero rework are observations, not effects against a baseline. (iii) Operator expertise as a confound. The practitioner’s dual background in education and software engineering likely contributed to the contextual grounding’s quality, so we cannot separate the methodology’s contribution from operator expertise. The team-variation sketch in Section 4.4 adds context but does not constitute controlled comparison.
6.2
Research Agenda
We propose five research questions and three concrete research lines that follow from the limitations above: RQ1: Does deliberate preparation reduce agent misalignment compared to iterative development? A comparative study pairing preparation-first and iteration-first workflows on matched tasks would establish whether the upfront investment yields net savings (addresses Limitation (ii)). RQ2: What constitutes “sufficient” context—can we define stopping criteria for the preparation phase? A saturation-style analysis of alignment quality vs. context volume would help practitioners know when to stop preparing. RQ3: How does context fluency vary across practitioners, domains, and agent models? A multi-team replication study generalizing the sketch in Section 4.4 could reveal whether context fluency is trainable or a function of prior domain knowledge [16] (addresses Limitation (iii)). RQ4: Can MEP scale beyond prototyping to multi-month development? A longitudinal study of context-fluency development would test scale applicability [4] (addresses Limitation (i)). RQ5: What is the relationship between preparation time and implementation quality? A multi-project dataset could yield quantitative models of the preparation-quality relationship [1]. The three named lines—comparative, replication, and longitudinal— convert the empirical concerns into a falsifiable program; RQ1 is the most immediately tractable.
6.3
Artifact Availability
To support the SIGSOFT Open Science Policy and enable replication, we release a research artifact bundle containing the anonymized hackathon data (timing, commit, and bead records reported in this paper), the prompts and agent configurations used, and the context-engineering scaffolds (CLAUDE.md, beads schema, planning templates) that constitute the MEP harness. The bundle is licensed CC-BY 4.0 (data) and MIT (code). It is archived on Zenodo at https://doi.org/10.5281/zenodo.19868258.
6.4
VibeX 2026, 9–12 June, 2026, Glasgow, Scotland, United Kingdom
Conclusion
MEP is a starting framework—a formalization of practices that experienced practitioners converge on independently [9, 10, 22], grounded in what Nonaka and Takeuchi [14] term externalization. We claim no generalizability from a single hackathon, but argue that the alignment problem in agentic coding is fundamentally a preparation problem, deserving treatment as a first-class engineering discipline. Context fluency names the emerging practitioner skill at the intersection of domain expertise and specification craft [2, 7].
References [1] Eman Abdullah Alomar et al. 2025. Promptware Engineering: The New Frontier of Software Engineering. arXiv preprint arXiv:2503.02400 (2025). doi:10.48550/ arXiv.2503.02400 [2] Anthropic. 2025. Effective Context Engineering for AI Agents. Anthropic Documentation. https://docs.anthropic.com/en/docs/build-with-claude/contextengineering [3] Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language Models are Few-Shot Learners. In Advances in Neural Information Processing Systems (NeurIPS). [4] Arghavan Moradi Dakhel et al. 2025. A Taxonomy of Human-AI Collaboration in Software Engineering. arXiv preprint arXiv:2501.08774 (2025). doi:10.48550/ arXiv.2501.08774 [5] Jeffrey Emanuel. 2025. beads_rust: High-Performance Task Tracking for AI Agents. GitHub repository. https://github.com/Dicklesworthstone/beads_rust [6] Gartner. 2025. Context Engineering Is In, Prompt Engineering Is Out. Gartner Research Note. Gartner identified context engineering as a key shift in AI application development for 2025. [7] GitHub. 2025. Spec Kit: Specification-Driven Development for AI Agents. GitHub repository. https://github.com/github/spec-kit [8] Hacks/Hackers and The Atlantic and Infactory. 2026. Building Future AI News Experiences with The Atlantic and Infactory. Hackathon event description. Approximately 12 teams, five-hour build window, $5,000 prize for top project. [9] Dex Horthy. 2025. The RPI Methodology: Research, Plan, Implement for Agentic Coding. HumanLayer Blog. https://humanlayer.dev/blog/rpi-methodology [10] Geoffrey Huntley. 2025. The Ralph Loop: A Pattern for AI Agent Iteration. Blog post. https://ghuntley.com/ralph/ [11] Andrej Karpathy. 2025. Vibe Coding. Twitter/X post. https://x.com/karpathy/ status/1886192184808149383 Term entered Merriam-Webster and Collins Dictionary in 2025. [12] Pengfei Liu, Weizhe Yuan, Jinlan Fu, Zhengbao Jiang, Hiroaki Hayashi, and Graham Neubig. 2023. Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing. Comput. Surveys 55, 9 (2023), 1–35. doi:10.1145/3560815 [13] Hussein Mozannar et al. 2023. Reading Between the Lines: Modeling User Behavior and Costs in AI-Assisted Programming. arXiv preprint arXiv:2210.14306 (2023). doi:10.48550/arXiv.2210.14306 [14] Ikujiro Nonaka and Hirotaka Takeuchi. 1995. The Knowledge-Creating Company: How Japanese Companies Create the Dynamics of Innovation. Oxford University Press, New York. [15] Sida Peng, Eirini Kalliamvakou, Peter Cihon, and Mert Demirer. 2023. The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. arXiv preprint arXiv:2302.06590 (2023). doi:10.48550/arXiv.2302.06590 [16] Michael Polanyi. 1958. Personal Knowledge: Towards a Post-Critical Philosophy. University of Chicago Press, Chicago, IL. [17] Michael Polanyi. 1966. The Tacit Dimension. University of Chicago Press, Chicago, IL. [18] Marisa Vasconcelos, Jack Jamieson, Umang Bhatt, and Q. Vera Liao. 2024. Understanding Trust in AI-Assisted Code Generation. In Proceedings of the ACM Conference on Fairness, Accountability, and Transparency (FAccT). ACM, New York, NY. [19] Veracode. 2025. State of Software Security: The Rise of AI Code. Industry report. Reports that 45% of AI-generated code contains security flaws, with a 10x spike in security findings from AI-generated code by June 2025. [20] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. 2022. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. In Advances in Neural Information Processing Systems (NeurIPS). [21] Grant Wiggins and Jay McTighe. 1998. Understanding by Design. Association for Supervision and Curriculum Development, Alexandria, VA. [22] Steve Yegge. 2025. Beads: External Memory for AI Agents. GitHub repository. https://github.com/steveyegge/beads