Architect & Assemblers AI Coding Methodology

Step 1: Create the Genesis Document

Define your project's core purpose, scope, target audience, technical requirements, and success criteria. This document becomes the single source of truth—everything else flows from it.

Your Genesis Document should cover:

• Project Overview: Name, description, target audience, core problem solved, success metrics, monetization strategy (if applicable)
• Technical Foundation: Platform(s), technology stack, performance requirements, scalability needs, security considerations
• Reference Analysis: Similar existing systems, features to emulate or improve, potential technical challenges

Be as specific as possible. The more clarity you provide here, the better the AI will perform later. Vague requirements produce vague code.

Step 2: System Identification and Decomposition

Break the project into manageable, independent Systems, then decompose into Components and Micro-Features. This hierarchical breakdown is where the methodology earns its keep.

The Hierarchy:

• Systems: Major functional areas (e.g., User Authentication, Recipe Management, Search)
• Components: Major features within each system (e.g., Recipe Storage, Recipe Search, Recipe Display)
• Micro-Features: The smallest individually codable units—think single function level

For each Micro-Feature, document: Name, Description, Inputs, Outputs, Expected Behavior, and Error Conditions. This level of detail might feel tedious, but it's exactly what AI needs to generate useful code.

Think of it this way: if you can't describe what a function should do in plain English, you're not ready to have AI write it.

Step 3: Architectural Diagramming and Relationship Mapping

Visualize the system architecture and define relationships between components. This is the deep mapping that prevents integration nightmares later.

Create these maps:

• System & Component Relationship Map: Which components belong to which systems
• Cross-System Communication Map: How different systems interact through their Gatekeeper APIs (more on this below)
• Component Import & Function Call Map: Which files import which, which functions call which
• Variable & Data Structure Map: All global variables, data structures, and their scope

The Gatekeeper Pattern: For each System, designate a "Gatekeeper" file (e.g., api.py) that handles all external interactions. Systems only talk to each other through these Gatekeepers. This keeps coupling manageable and makes testing straightforward.

Step 4: AI-Assisted Architecture Review

Here's where the Multi-AI workflow comes in. Get feedback from multiple AI models on your proposed designs.

Useful prompts:

• "Critique this architecture for potential bottlenecks, scalability issues, or security vulnerabilities."
• "Suggest alternative architectural approaches for this system."
• "Identify any potential tight coupling or dependencies that could cause problems."
• "Evaluate this technology stack for a project with these requirements."

Use different LLMs for diverse perspectives—Claude might catch something GPT misses, and vice versa. Document the feedback and your rationale for changes. This creates a decision trail you'll appreciate later.

Step 5: File/Folder Structure Setup

Create the physical directory structure and empty files matching your architecture. Add basic import statements reflecting planned dependencies.

Why this matters: Pre-emptive setup prevents naming inconsistencies and ensures AI generates code in correct locations. When you prompt an AI to write a function, you can specify exactly where it goes and what it can access. No ambiguity.

Step 1: AI Role Assignment

Not all AIs are equal for all tasks. Figure out which model works best for what.

Process:

• Create test micro-features from different systems
• Prompt each AI to generate code for these tests
• Evaluate output on: Correctness, Efficiency, Readability, Style adherence, Documentation quality
• Assign roles: Primary Coder, Style Reviewer, Logic Reviewer, Security Auditor

This is the AI Capability Profiling from the Cognitive Mirror, applied to code. Document what each AI does well—you'll reference this constantly.

Step 2: The Micro-Feature Implementation Cycle

This is the core loop. Repeat for each Micro-Feature:

1. Initial Prompting: Craft a detailed prompt for your Primary Coder. Include the micro-feature description, file location, inputs/outputs, relevant global variables, style requirements, and error handling expectations. The more context, the better the output.
2. Code Review: Share the generated code with your Reviewer AIs. Have them critique for correctness, efficiency, style, and edge cases. This is AI Critique AI in action.
3. Refinement: Based on feedback, either prompt the Primary Coder to refine or modify manually. Sometimes human judgment is faster.
4. Iteration: Repeat until you're satisfied with code quality. Usually takes 2-3 passes.

Step 2.5: Creating the Basic Framework

Before diving deep into features, get your files communicating. Create basic functions in each file, have them call each other, run to verify. This catches structural issues early—before you've invested hours in detailed implementation.

Step 3: Unit Testing

Write unit tests for each Micro-Feature before integration. Use AI to help generate test cases covering various inputs, edge cases, and error conditions.

Aim for high test coverage. Tests catch bugs early and make future changes safer. They also serve as documentation—a test that shows expected behavior is worth a thousand comments.

Integration Sequence

1. Component Integration: Combine Micro-Features within a Component. Test interactions between Micro-Features. Use version control to track changes—you'll want rollback capability.
2. System Integration: Connect Components within a System via your Gatekeeper APIs. Focus testing on interfaces between Components.
3. Cross-System Integration: Connect different Systems according to your Communication Map. Perform end-to-end testing simulating real user scenarios.

Each level catches different types of bugs. Component integration catches logic errors. System integration catches interface mismatches. Cross-system integration catches architectural flaws.

System-Wide Testing

• Functional Testing: Verify all features work as expected
• Performance Testing: Measure response times, resource usage, scalability
• Security Testing: Identify and address potential vulnerabilities
• User Acceptance Testing: If possible, have real users test and provide feedback

Document all test results and track identified issues. This becomes your quality baseline for future releases.

Scaling and Infrastructure

When you need to handle more load, you'll need infrastructure changes:

• Horizontal Scaling: Adding more instances of your application servers
• Vertical Scaling: Increasing resources (CPU, RAM, storage) of existing servers
• Database Scaling: Replication, sharding, or distributed database systems
• Caching: Redis, Memcached to reduce database load
• CDN: Distribute static assets closer to users

AI can help here too. Try: "We're expecting 10,000 concurrent users. Suggest a cloud infrastructure setup using AWS for a Python/Django web application with a PostgreSQL database."