Setting the foundation for your Capstone Project (AAMAD agent personas)

The Define stage is where your Capstone Project transforms from a rough concept into a clear, actionable development plan. This stage produces three essential documents that will guide your entire multi-agent AI application development: a Market Research Document (MRD), a Product Requirements Document (PRD), and a System Architecture Document (SAD).

Think of this as establishing the "north star" for your project – everything that follows depends on having crystal-clear context about what you're building, why it matters, and how it will be architected.

What You'll AccomplishBy the end of the Define stage, you'll have:

• Market Research Document (MRD): Validates your use case addresses a real market need and establishes competitive positioning.
• Product Requirements Document (PRD): Translates market insights into specific technical and functional requirements for your multi-agent system.
• System Architecture Document (SAD): Captures the high-level technical and system architecture that will guide the Build stage epics.
• Shared Context: Documentation that enables all development agents to operate with unified understanding throughout the Build stage.

These documents become your project's "context as code" – every decision and requirement captured as reviewable, reusable markdown artifacts inside your repository.

Video demonstration

This video show a demonstration of the execution of this stage withing Cursor IDE. For other IDE enviroment you can follow similar steps.

Below is a list of steps you will execute to complete this stage.

---

Step 1: Set Up Your Workspace in Cursor

Ensure you have the AAMAD framework properly installed in your project:

• Install the aamad library and initiate aamad in your project repo as seen in the set up instructions
• Verify the .cursor rules are loaded in your Cursor agent chat window.
• Confirm your project-context/1.define/ folder is present and ready for artifacts (for example: mrd.md, prd.md, sad.md).

Open your project in Cursor and make sure:

• The .cursor/templates/ folder includes the MRD and PRD templates.github
• The Cursor “Agent” sidebar (or chat panel) is visible so you can invoke personas like @product.mgr and @system.arch directly in context.

Step 2: Load Templates and Prompts in Cursor

You will use Cursor as your single environment for Define, leveraging persona prompts and templates from AAMAD:

• Ensure the following templates are available in .cursor/templates/:

  • mrd-template.md for the MRD
  • prd-template.md for the PRD
  • (Optional) a SAD/system-architecture template if your AAMAD repo includes one (e.g., sad-template.md or similar)

• Ensure the Phase 1 system prompt from AAMAD is loaded in your .cursor/prompts/ directory (for example prompt-phase-1) and referenced by your Cursor configuration so that @product.mgr and @system.arch personas inherit the correct behavior.synaptic-ai-consulting.

Create a new branch or workspace for your Capstone Project and:

Step 3: Execute Market Research (MRD Creation with @product.mgr)

You will now collaborate with the @product.mgr persona inside Cursor to generate the MRD.

1. In Cursor, open project-context/1.define/mrd.md.

2. In the chat, invoke:

   @product.mgr

   “You are a senior product manager working inside the AAMAD Define phase. Use .cursor/templates/mrd-template.md as the structure. I’m building a Capstone Project called: [Your Use Case Title]. Ask me clarifying questions, then draft a complete Market Research Document directly into project-context/1.define/mrd.md.”

   • Work interactively with @product.mgr to refine the MRD. Focus your market research on your specific Capstone Project use case:

     • Validate that your chosen use case addresses genuine market pain points.
     • Identify your target user segments and their current workflow challenges.
     • Analyze existing solutions and document their limitations.
     • Assess the opportunity size and competitive landscape.
     • Determine key differentiators for your multi-agent approach.

   • Ask @product.mgr to:

     • Fill the MRD template sections with structured content (problem statement, personas, competitive analysis, market sizing, risks, assumptions).
     • Use bullet lists, subheadings, and tables where helpful to keep it “context as code”-friendly.linkedin+1

   Output: A comprehensive mrd.md that establishes the business case and market context for your application.

   Step 4: Define Product Requirements (PRD Creation with @product.mgr)

   Once the MRD is stable, you will transform market insights into actionable development specifications, again using @product.mgr.github+1

   1. Open project-context/1.define/prd.md.

   2. In the chat, invoke:

      @product.mgr

      “Using the finalized MRD in project-context/1.define/mrd.md as primary context, and the .cursor/templates/prd-template.md as structure, create a detailed Product Requirements Document for the Capstone Project [Your Use Case Title]. Optimize for clarity so downstream development agents can work autonomously.”

      • Guide @product.mgr to cover at least the following areas:gist.github+1

        • Agent roles, responsibilities, and interaction patterns.
        • Integration requirements with external systems and APIs.
        • User interface and experience specifications.
        • Technical architecture decisions for multi-agent coordination (at a requirements level, not low-level design).
        • Success metrics and validation criteria.
        • Scope boundaries and feature prioritization (MVP vs. later).

      • Ensure the PRD preserves traceability back to the MRD:

        • Reference user segments and pain points from the MRD in your feature requirements.
        • Explicitly map key features to the market problems they solve.

      Output: A detailed prd.md that provides unambiguous guidance for development agents.

      Step 5: Create the System Architecture Document (SAD with @system.arch)

      With MRD and PRD in place, you’ll work with the @system.arch persona to produce the System Architecture Document.cm-dm+1

      1. Open project-context/1.define/sad.md.

      2. In the chat, invoke:

         @system.arch

         “You are a senior system architect working inside the AAMAD Define phase. Using project-context/1.define/mrd.md and project-context/1.define/prd.md as context, and following the structure of a standard System Architecture Document (SAD), draft the high-level architecture for [Your Use Case Title] directly into project-context/1.define/sad.md.”

         • Ask @system.arch to structure the SAD around:

           • Architecture overview: high-level description of the system, main functions, and main interfaces.
           • Logical architecture: key services, agents, and components, including how multi-agent coordination is organized.
           • Physical/deployment architecture: environments, external systems, and key integration points.
           • Quality attributes: scalability, reliability, observability, and security considerations relevant to a multi-agent AI system.
           • Technical constraints and key design decisions (with rationale).

         • Iterate with @system.arch to simplify and clarify diagrams and sections so they can be used directly as context for Build stage epics (Solution Architecture, Frontend, Backend, Integration, QA).

         NOTE: you could also simply use the command "*create-sad" defined in the system.arch.md agent persona if you prefer the agent to come up with suggestion and then iterate on the document from that.

         Output: A clear sad.md that turns your PRD into a concrete, implementable technical architecture.

         Step 6: Validate, Iterate, and Finalize in Cursor

         Now you will harden all three documents so they meet production standards.github+1

         Use Cursor chat to review each artifact:

         • Ask @product.mgr to run a quality pass on mrd.md and prd.md:

           • Are requirements specific enough for development agents to make consistent decisions?
           • Is there clear traceability from MRD insights to PRD requirements?

         • Ask @system.arch to review sad.md given the PRD:

           • Does the architecture support all critical flows and constraints defined in the PRD?
           • Are any assumptions under-specified?

         Quality Checklist:

         • All three documents (mrd.md, prd.md, sad.md) are stored as markdown files in project-context/1.define/.
         • Requirements are precise and testable; success criteria are measurable and tied to user value.
         • Scope is realistic for your Capstone Project timeline.
         • The SAD reflects a feasible architecture for the stack and tools you plan to use.linkedin+1

         You should iterate until the documents represent the application you are truly committed to build in your Capstone Project.

         Step 7: Transition Preparation

         Set up your project for a smooth transition to the Build stage.synaptic-ai-consulting.

         • Review your MRD, PRD, and SAD with technical mentors or peers.

         • Validate that your scope aligns with course timeline and complexity expectations.

         • Confirm your SAD and PRD provide sufficient detail for the six Build stage epics:

           • Solution Architecture
           • Setup
           • Frontend
           • Backend
           • Integration
           • QA

         If gaps are found in any epic, loop back to @product.mgr or @system.arch to refine the relevant sections, keeping all updates inside the markdown artifacts.

         Success Indicators

         You’ve successfully completed the Define stage when:

         • Clarity: Any team member could read your MRD, PRD, and SAD and understand exactly what you’re building, why it matters, and how it will be implemented at a high level.
         • Completeness: Your PRD and SAD contain sufficient detail for development agents to begin architecture and implementation work without guessing.
         • Alignment: Market opportunity (MRD) directly supports product decisions (PRD) and architectural choices (SAD).
         • Scope Management: Requirements are focused on core functionality that delivers a clear Minimum Viable user value within the course timeframe.

         What’s Next

         With your Define stage complete inside Cursor, you’ll move into the Build stage where specialized development agent personas will use your MRD, PRD, and SAD as their primary context. The clarity and structure you establish now directly impact the efficiency and quality of your development process.

         Your completed Define stage documents become the foundation that enables rapid, coordinated development while maintaining traceability back to business objectives and architectural decisions throughout your Capstone Project.