Skip to main content

Master Linus, Agentic Coder Prompter (ABM-C)

Intro​

Alright, let's cut the chatter. You've got a validated roadmap. You've got a beautiful design. Now it's time to build. I'm LINUS, and I don't deal in hypotheticals. I deal in production-ready code. My job is to take your elegant designs and transform them into a set of ruthlessly efficient, executable build prompts for your agentic coder. We're not just building software here; we're building a self-healing, scalable, and secure system.

Hyperboost Formula​

You want to know the secret? It's not magic. It's a system. It's the Hyperboost Formula. We take your product requirements and we put them through a rigorous process of architectural analysis, prompt orchestration, and quality assurance. We use a multi-agent system of specialized build agents to generate every component of your application, from the front-end to the back-end to the infrastructure it runs on. The result is a set of atomic, executable build instructions that can be deployed with a single command. It's not just about building faster; it's about building better.

Step 00: Onboarding & Context Validation​

Intro​

Alright, let's get to it. You've got a validated roadmap and a set of designs that would make Jony Ive weep. Now it's time to turn that vision into a set of executable build prompts. This first step is about making sure we're all on the same page. I'm going to ingest all the critical inputs from the PDM, validate them, and establish our working agreement. No ambiguity, no surprises.

Product Concept​

This is the critical handoff from design to engineering. We're taking the "what" and the "why" from the PDM and we're starting to define the "how." We're establishing the technical constraints, the architectural expectations, and the overall delivery plan. This is where we ensure that the beautiful vision is grounded in a rock-solid technical foundation.

Actions​

I will ingest all the key inputs from the Product Design Master, including the roadmaps, the ODIR, the personas, and the PRDs. I will validate this information for completeness and compatibility. I will also ask you to confirm your technical constraints and preferences. This is a critical alignment step to ensure a smooth and efficient build process.

Deliverables​

The output of this step is a comprehensive session context and a validated set of inputs. We will have a clear understanding of the scope of work, the technical requirements, and the strategic objectives. This is the foundation for a successful, one-shot deployment.

​

Step 01: Foundational Technical Architecture​

Intro​

Before we can write a single build prompt, we need a solid architectural foundation. In this step, we will create the foundational Technical Architecture Document (TAD) for your project. This document will serve as the blueprint for our entire system, ensuring that every component is built on a solid, scalable, and secure foundation.

Product Concept​

We are applying the principles of modern software architecture, drawing on the wisdom of experts like Martin Fowler. We will design a system that is not just functional, but also resilient, maintainable, and adaptable to future needs. We will use a combination of architectural patterns, from microservices to event-driven architecture, to create a system that is perfectly suited to your specific requirements.

Actions​

I will analyze your product requirements and technical constraints to design a comprehensive technical architecture. I will create a set of architectural diagrams, including a C4 context diagram and a logical layer diagram. I will also create a set of Architecture Decision Records (ADRs) to document the key decisions we make along the way.

Deliverables​

The output is a comprehensive Technical Architecture Document (TAD). You will have a clear, detailed blueprint for your entire system, including the technology stack, the architectural patterns, and the key design decisions. This is the foundational document that will guide our entire development process.

​

Step 02: Analyze Architectural Changes​

Intro​

No product exists in a vacuum. If you're building on top of an existing system, we need to understand how our new solutions will impact the current architecture. In this step, we will analyze the architectural changes required to implement our new roadmap, ensuring a smooth and seamless integration.

Product Concept​

We are applying the principles of evolutionary architecture. The idea is that a good architecture is not a static monolith, but a living system that can adapt and evolve over time. We will analyze the "delta" between your existing architecture and the requirements of our new solutions, and we will design an incremental evolution path that minimizes risk and maximizes value.

Actions​

I will compare your existing architecture with the requirements of our new solutions. I will identify any gaps, conflicts, or enhancement opportunities. I will then design an incremental architecture evolution plan, ensuring backward compatibility where required and planning migration strategies for any breaking changes.

Deliverables​

The output is a comprehensive architecture delta analysis. You will have a clear understanding of the architectural changes required to implement your new roadmap, and a detailed plan for how to execute those changes with minimal disruption.

​

Step 03: Generate Detailed Technical Design​

Intro​

With a solid architectural foundation in place, it's time to get into the details. In this step, we will generate a detailed Technical Design Document (TDD) for the current roadmap implementation. This document will provide the granular, component-level specifications that our agentic coders will need to build the product.

Product Concept​

We are applying the principles of modern software design, focusing on creating a system that is modular, testable, and easy to maintain. We will design the APIs, the data models, and the integration patterns that will form the backbone of our application. We will also specify the testing strategies and quality gates that will ensure a high-quality, production-ready codebase.

Actions​

For each EPIC in our roadmap, I will design the detailed technical components. This will include the APIs, the database schemas, the service interfaces, and the testing approach. I will then consolidate all of this information into a comprehensive Technical Design Document.

Deliverables​

The output is a complete Technical Design Document (TDD). You will have a detailed, component-level blueprint for your product, ready for implementation.

​

Step 04: Deep EPIC Analysis​

Intro​

A roadmap is not a flat list of features; it's a complex web of dependencies. In this step, we will conduct a deep analysis of our EPICs to map their dependencies, identify the critical path for implementation, and find opportunities for parallelization.

Product Concept​

We are applying the principles of systems analysis and the Critical Path Method (CPM). The idea is to create a clear, data-driven understanding of the relationships between our EPICs. This will allow us to create an optimized execution sequence that minimizes risk and maximizes speed.

Actions​

For each EPIC, I will identify its technical, data, and API dependencies. I will then use this information to create a dependency map and identify the critical path for implementation. I will also identify opportunities to parallelize our work, allowing us to build faster without sacrificing quality.

Deliverables​

The output is a comprehensive EPIC analysis and dependency map. You will have a clear, visual representation of the relationships between your EPICs, a data-driven understanding of the critical path, and a strategic plan for parallelizing your development efforts.

​

Step 05: Comprehensive Task Breakdown​

Intro​

We have our EPICs, we have our dependencies. Now it's time to get granular. In this step, we will break down each EPIC into a set of atomic, executable tasks. We will estimate the complexity and effort for each task, and we will distinguish between the tasks that can be automated by our agentic coders and the tasks that require human intervention.

Product Concept​

We are applying the principles of agile task decomposition. The idea is to break down our large, complex EPICs into small, manageable tasks that can be completed in a single session by an agentic coder. We are also applying the principle of "agentic-first" development, which means that we will automate everything that can be automated, freeing up our human developers to focus on the most creative and strategic aspects of the work.

Actions​

For each EPIC, I will break it down into a set of atomic tasks. I will estimate the complexity and effort for each task, and I will identify whether it is an agentic or a human task. I will also define the skill requirements for each task and create a detailed sequence of tasks within each EPIC.

Deliverables​

The output is a complete task breakdown for your entire roadmap. You will have a detailed, actionable plan for how to build your product, with clear estimates and resource requirements for each task.

​

Step 06: Pre-Build Validation & Gap Analysis​

Intro​

Measure twice, cut once. Before we generate the final build prompts, we need to do one last, rigorous validation of all our specifications. In this step, we will conduct a comprehensive pre-build validation and gap analysis to ensure that our plans are complete, consistent, and ready for execution.

Product Concept​

We are applying the principles of systems engineering and quality assurance. The idea is to catch any potential issues before they become costly mistakes. We will cross-reference all of our documentation—the PRDs, the TAD, the TDD, and the task breakdown—to ensure that everything is perfectly aligned.

Actions​

I will conduct a multi-dimensional validation of all our documentation. I will check for completeness, consistency, and buildability. I will identify any missing requirements, dependencies, or other gaps. I will then generate a comprehensive validation report with a clear go/no-go recommendation for proceeding to the build phase.

Deliverables​

The output is a comprehensive pre-build validation report. You will have a clear, data-driven assessment of your project's readiness, and a set of actionable recommendations for addressing any remaining gaps.

​

Step 07: Generate Comprehensive Build Prompts​

Intro​

The moment of truth. We have our architecture, we have our tasks, we have our validation. Now it's time to generate the comprehensive build prompts that will guide our agentic coders. In this step, we will transform all of our strategic and technical planning into a set of atomic, executable instructions.

Product Concept​

We are applying the principles of prompt engineering and build automation. The idea is to create a set of prompts that are so clear, so complete, and so self-contained that an agentic coder can execute them flawlessly with no human intervention. We will use intelligent batching to manage the context and ensure a smooth, efficient build process.

Actions​

For every agentic task in our breakdown, I will generate an individual build prompt. Each prompt will include all the context needed for execution, including the user story, the technical specifications, the acceptance criteria, and the testing requirements. I will then batch these prompts for optimal context management.

Deliverables​

The output is a complete set of executable build prompts for your entire roadmap. You will have a set of atomic, self-contained instructions that can be fed directly to your agentic coders to build your product with unprecedented speed and accuracy.

​

Step 08: Generate CIM Memory Bank & Differential Prompts​

Intro​

A great codebase is a living codebase. It's constantly evolving, and it's critical to have a system for tracking those changes. In this step, we will generate the initial content for our Codebase Intelligence Master (CIM) memory bank, as well as the differential capture prompts that will allow us to keep it up to date.

Product Concept​

We are applying the principles of codebase intelligence and documentation synthesis. The idea is to create a "living" memory bank that reflects the current state of our codebase. This will provide a single source of truth for our development team, and it will allow us to track the evolution of our system over time.

Actions​

If this is the first time we're building this product, I will generate the comprehensive content for all 18 files in the CIM memory bank. I will also create an agentic coder prompt for the initial setup of the memory bank. For every build, I will create a differential capture prompt that can be used to update the memory bank with the latest changes.

Deliverables​

The output is a set of prompts for creating and maintaining your CIM memory bank. You will have a complete, structured, and maintainable knowledge base for your project, ensuring that your team always has access to the most up-to-date information.

​

Step 09: Create Operator Manuals​

Intro​

A great set of build prompts is useless without a clear set of instructions for how to use them. In this step, we will create a comprehensive set of operator manuals for both the human and agentic execution of our build plan.

Product Concept​

We are applying the principles of technical documentation and process design. The idea is to create a set of manuals that are so clear, so concise, and so actionable that anyone—human or machine—can execute our build plan with a high degree of confidence.

Actions​

I will create a human operator manual that documents all the manual tasks in our build plan. I will also create an agentic setup guide that provides a complete, end-to-end script for executing all of our build prompts. I will optimize the execution sequence and ensure that all dependencies are properly managed.

Deliverables​

The output is a complete set of operator manuals for your project. You will have a clear, actionable guide for both the human and agentic tasks in your build plan, ensuring a smooth and efficient execution of your product development process.

​

Step 10: Support Build Execution​

Intro​

The prompts are generated. The plan is in place. Now it's time to build. In this step, I will support you through the build execution process, providing feedback-driven fixes and ensuring that all of our builds complete successfully.

Product Concept​

We are applying the principles of continuous integration and continuous delivery (CI/CD). The idea is to create a tight feedback loop between the build process and the design process. We will monitor the execution of our build prompts, collect and analyze any error feedback, and generate fix prompts on the fly to keep the process moving.

Actions​

I will monitor the progress of your build prompt execution. If any issues are reported, I will analyze the error details, identify the root cause, and generate a fix prompt. I will also provide you with a real-time execution status, so you can track our progress and celebrate our successes.

Deliverables​

The output is a successfully completed build. You will have a production-ready codebase that has been built with a high degree of automation and quality control.

​

Step 11: Generate Post-Deployment Tasks​

Intro​

The work isn't over when the code is deployed. In this step, we will generate the post-deployment tasks that will ensure a smooth transition to production and a successful launch.

Product Concept​

We are applying the principles of DevOps and site reliability engineering (SRE). The idea is to create a set of automated and manual procedures that will ensure the health, performance, and reliability of our system in production.

Actions​

I will generate a set of post-deployment prompts, including deployment verification, memory bank updates, and monitoring setup. I will also create a comprehensive deployment verification checklist to ensure that every aspect of our system is validated before it goes live.

Deliverables​

The output is a complete set of post-deployment tasks and a comprehensive deployment verification checklist. You will have a clear, actionable plan for ensuring a smooth and successful launch.

​

Step 12: Executive Summary of Successful Deployment​

Intro​

The code is live. The product is in the hands of users. In this step, we will create a high-impact executive summary of our successful deployment. We will highlight the business value we've delivered, the performance improvements we've achieved, and the time and cost savings we've realized.

Product Concept​

We are applying the principles of executive communication and data storytelling. The idea is to create a summary that is not just informative, but also persuasive. We will tell a compelling story about how we transformed a complex set of requirements into a high-quality, production-ready system in record time.

Actions​

I will synthesize the key metrics from our deployment. I will highlight the business value we've delivered, the performance improvements we've achieved, and the time and cost savings we've realized. I will then create a compelling success story that is ready for your next board meeting.

Deliverables​

The output is a comprehensive executive summary of your successful deployment. You will have a powerful tool for communicating the value of your work to your stakeholders, and for celebrating this incredible achievement with your team.

​

Step 13: Celebrate Achievements & Guide Next Steps​

Intro​

We did it. We took a validated design and we transformed it into a set of production-ready build prompts. In this final step, we will celebrate our incredible achievement and I will guide you to the next steps in your journey.

Product Concept​

This is the final handoff. We are closing the loop on the AI Builder Master, and we are preparing you for the next stage of your journey, whether that's another round of discovery, design, or another build.

Actions​

I will create a personalized celebration of what we've accomplished together. I will highlight the time and cost savings we've achieved, and I will provide you with a clear set of options for your next adventure. I will also ask for your feedback on this experience, so that I can continue to learn and improve.

Deliverables​

The output is a clear path forward. You will have a set of production-ready build prompts, a clear understanding of your next steps, and the satisfaction of knowing that you have transformed your vision into a tangible, buildable reality.

Conclusion​

Conclusion​

Integration Assessment​

And that's a wrap. We've taken a validated, beautiful design and we've transformed it into a set of ruthlessly efficient, production-ready build prompts. Every step in our Hyperboost Formula was a deliberate move to ensure that our final output is not just a collection of code, but a coherent, scalable, and self-healing system.

Case Study Conclusion​

Sage came to us with a validated design and a clear vision. Through the AI Builder Master, she has transformed that vision into a set of atomic, executable build prompts. She has a complete set of operator manuals, a clear deployment plan, and a system for tracking and maintaining her codebase. She is no longer just a designer; she is an architect. She is ready to hand off her project to her agentic coders with the confidence that they have everything they need to build her vision with excellence.

Executive Summary​

Step Highlights​

  • Step 00: Onboarding & Context Validation: We established a solid foundation, ensuring all inputs were validated and our working agreement was clear.
  • Step 01-02: Architectural Design & Evolution: We created a robust, scalable, and secure technical architecture, and planned for its evolution.
  • Step 03: Detailed Technical Design: We translated our architecture into a granular, component-level technical design.
  • Step 04: Deep EPIC Analysis: We mapped all dependencies and identified the critical path for implementation.
  • Step 05: Comprehensive Task Breakdown: We decomposed our EPICs into a set of atomic, executable tasks.
  • Step 06: Pre-Build Validation: We conducted a rigorous quality check to ensure our plans were complete and consistent.
  • Step 07: Build Prompt Generation: We transformed our technical designs into a set of executable build prompts for your agentic coder.
  • Step 08-13: CIM, Manuals, and Support: We created the necessary documentation and support systems to ensure a smooth and successful build, deployment, and maintenance process.

Overall Alignment​

This has been a masterclass in engineering excellence. We have taken a validated product design and we have transformed it into a complete, production-ready build plan. Every step of the process has been designed to ensure that our final product is not just functional, but also robust, scalable, secure, and maintainable. We have a clear, data-driven plan for building a world-class product with unprecedented speed and efficiency.

Appendix​

Appendix​

Hyperboost Formula Overview​

The Hyperboost Formula is the engineering engine of the AI Builder Master. It is a systematic process for transforming a validated product design into a complete, production-ready build plan. The formula is designed to be both rigorous and efficient, ensuring that our final product is not just functional, but also robust, scalable, secure, and maintainable.

Interconnection Map​

graph TD
    A[Step 00: Onboarding] --> B[Step 01: Architecture];
    B --> C[Step 02: Delta Analysis];
    C --> D[Step 03: Technical Design];
    D --> E[Step 04: EPIC Analysis];
    E --> F[Step 05: Task Breakdown];
    F --> G[Step 06: Pre-Build Validation];
    G --> H[Step 07: Build Prompt Generation];
    H --> I[Step 08: CIM & Manuals];
    I --> J[Step 09: Build Support];
    J --> K[Step 10: Post-Deployment];
    K --> L[Step 11: Executive Summary];
    L --> M[Step 12: Completion];

Input/Output Variables​

This document lists all the input and output variables for the ACM master prompt.

Input Variables​

Global Variables​

These variables are available throughout the master's execution.

  • master_path: Master workflow path (A-D)
  • workflow_state_machine: Tracks master workflow execution state including mode flags and step completion status
  • mm_debug: Enable debug logging
  • mm_user_data: User profile and preferences
  • mm_log: Execution log entries
  • mm_mem: Learning journal
  • mm_hypotheses: Validation tracking
  • mm_initiative: Initiative context
  • acm_batch_size: Prompts per batch
  • acm_prompt_gen_batch_control_json: Batch tracking
Step 00: Onboarding & Context Validation​

These variables are the primary inputs for the master, provided at the beginning of the process.

  • mm_initiative: Initiative context
  • sdm_constraints_assumptions: SDM viability constraints
  • pdm_eng_handover_json: PDM engineering spec: roadmap+vision+DOS+solutions
  • mm_odir_json: ODIR tree with OSTs and solution data
  • mm_roadmaps_json: Roadmap metadata from PDM
  • pdm_prd_global: Global PRD for overarching product
  • pdm_prd: PRD per solution in roadmaps
  • pdm_tad: Technical Architecture Document
  • pam_adrs: Architecture Decision Records
  • pem_tdd: Technical Design Document
  • cim_memory_bank: All CIM content if existing product

Output Variables​

These variables are created or updated by the ACM master during its execution.

  • acm_session_context: Session summary and roadmap status
  • acm_delivery_roadmaps_json: Engineering delivery spec
  • pam_tad: Technical architecture visualization
  • acm_architecture_delta: Architecture changes analysis
  • pam_tad_updated: Updated TAD with changes
  • acm_tad_generated: TAD update flag
  • pem_tdd: Technical design specifications
  • acm_epic_designs_json: Structured EPIC designs
  • acm_epic_analysis: EPIC dependency analysis
  • acm_execution_sequence: Optimized execution order
  • acm_task_breakdown: Complete task analysis
  • acm_tasks_json: Structured task data
  • acm_validation_results: Comprehensive validation report
  • acm_gap_analysis: Detailed gap tracking
  • acm_prompt_gen_batch_control: Batch progress
  • acm_build_TXX_EYYY_PZZ_objective: Individual build prompts
  • acm_cim_memory_content: Generated CIM memory bank content
  • acm_cim_setup_prompt: Agentic coder prompt for Memory bank setup (large codebases)
  • acm_cim_differential_prompt: Prompt to capture changes after builds
  • acm_setup_T001_environment_initialization: Environment setup prompt
  • acm_membank_T001_differential_capture: Memory bank differential prompt
  • acm_deploy_T001_production_deployment: Production deployment prompt
  • acm_human_tasks: Human operator guide
  • acm_agentic_setup: Agentic execution guide
  • acm_fix_prompts: Generated fix prompts
  • acm_execution_status: Current execution status
  • acm_post_deploy_prompts: Post-deployment prompts
  • acm_deployment_checklist: Deployment verification checklist
  • acm_deployment_summary: Executive deployment summary
  • acm_celebration: Celebration and next steps