Use cases

​

Use Case 1: Starting a New Project

​

The Scenario

​

Without Architect API

1. Start coding directly in Cursor/Lovable
2. Realize you’re missing features halfway through
3. Refactor multiple times
4. End up with technical debt

​

With Architect API

1. Describe your idea to Architect API
2. Get comprehensive spec with all necessary features
3. Paste spec into your agent
4. Agent builds with complete context from day one

​

Example: Building a Project Management Tool

{
  "input": "Build a SaaS project management tool with kanban boards, sprint planning, time tracking, team collaboration, and integrations with Slack and GitHub. Include user authentication with teams and roles.",
  "outputFormat": "url"
}

• Technical architecture (Next.js, PostgreSQL, real-time updates)
• 15+ user stories with acceptance criteria
• Implementation phases with effort estimates
• Risk analysis and mitigation strategies
• Task tracking system for progress management

​

Use Case 2: Adding Features to Existing Projects

​

The Scenario

​

Without Architect API

1. Describe new features in conversation with agent
2. Agent makes assumptions about existing architecture
3. Integration issues arise
4. Multiple refactoring cycles needed

​

With Architect API

1. Provide current codebase context
2. Get feature spec that respects existing architecture
3. Seamless integration with current system
4. No architectural conflicts

​

Example: Adding Real-Time Chat to E-commerce Platform

{
  "input": "Add real-time customer support chat with agent assignment, chat history, and file sharing",
  "currentContext": "Existing e-commerce platform with React frontend, Node.js API, PostgreSQL database, user authentication via JWT, product catalog, shopping cart, and order management",
  "outputFormat": "url"
}

• Integrates with existing user system
• Uses current tech stack (Socket.io with existing Node.js setup)
• Respects current database schema
• Includes migration considerations
• Provides implementation tasks that fit the existing codebase

​

Use Case 3: Team Collaboration

​

The Scenario

​

Without Architect API

• Vague requirements in tickets/issues
• Developers make different architectural assumptions
• Integration issues when merging work
• Inconsistent implementation patterns

​

With Architect API

• Single source of truth for requirements
• Clear task breakdown for delegation
• Consistent architectural decisions
• Progress tracking across team members

​

Example: Enterprise CRM Development

• 3 backend developers
• 2 frontend developers
• 1 DevOps engineer
• 1 QA engineer

1. Generate comprehensive Deep Spec with granular subtasks
2. Assign subtasks to team members based on expertise
3. Each developer works within their bounded context
4. Daily check-ins to update task progress
5. QA validates against acceptance criteria

• Parallel development without conflicts
• Consistent architecture across team
• Clear completion criteria for each task
• Reduced integration issues

​

Use Case 4: CI/CD Integration

​

The Scenario

​

Implementation

​

Example: Automated Feature Spec Generation

name: Generate Feature Spec
on:
  issues:
    types: [labeled]

jobs:
  generate-spec:
    if: github.event.label.name == 'needs-spec'
    runs-on: ubuntu-latest
    steps:
      - name: Generate Spec
        run: |
          curl -X POST https://api.pre.dev/fast-spec \
            -H "Authorization: Bearer ${{ secrets.ARCHITECT_API_KEY }}" \
            -H "Content-Type: application/json" \
            -d "{\"input\": \"${{ github.event.issue.body }}\", \"outputFormat\": \"markdown\"}" \
            > feature-spec.md

• Consistent spec format across all features
• Automated documentation generation
• Integration with existing development workflow
• Reduced manual overhead

​

Use Case 5: Multi-Agent Workflows

​

The Scenario

​

Without Architect API

• Agents have conflicting understandings of requirements
• Different architectural decisions
• Integration challenges
• Inconsistent implementation

​

With Architect API

• All agents work from the same specification
• Consistent architectural context
• Clear boundaries for each agent’s responsibilities
• Coordinated development across multiple agents

​

Example: Specialized Agent Team

• Architecture Agent: Reviews and refines the overall system design
• Backend Agent: Implements API endpoints and database logic
• Frontend Agent: Builds user interfaces and client-side logic
• Testing Agent: Creates comprehensive test suites

1. Generate comprehensive spec with clear separation of concerns
2. Each agent focuses on their assigned stories/tasks
3. Regular synchronization to ensure integration points work
4. Combined testing to validate the complete system

• Specialized expertise for each domain
• Parallel development across different layers
• Consistent implementation patterns
• Comprehensive test coverage

​

Use Case 6: Prototyping and Validation

​

The Scenario

​

Without Architect API

• Time-consuming manual prototyping
• Incomplete feature sets in demos
• Stakeholder feedback on incomplete implementations
• Multiple revision cycles

​

With Architect API

• Rapid comprehensive specifications
• Complete feature understanding upfront
• Better stakeholder alignment
• Focused development on validated requirements

​

Example: Startup MVP Validation

1. Generate Fast Spec for initial concept
2. Share spec with stakeholders for feedback
3. Iterate on spec based on input
4. Generate Deep Spec for final implementation
5. Build complete MVP with all features

• Faster validation cycles
• More complete understanding before coding
• Reduced development waste
• Better product-market fit

​

Use Case 7: Legacy System Modernization

​

The Scenario

​

Without Architect API

• Time spent reverse-engineering existing code
• Risk of breaking existing functionality
• Incomplete understanding of system behavior
• Architectural conflicts between old and new

​

With Architect API

• Structured analysis of existing system
• Clear modernization path
• Risk mitigation strategies
• Gradual migration planning

​

Example: Migrating Monolithic App to Microservices

{
  "input": "Modernize our monolithic e-commerce application by extracting the product catalog into a separate microservice with its own database and API",
  "currentContext": "Legacy PHP monolith with MySQL database, serving product catalog, user management, orders, and payments. High coupling between components, difficult to scale individual features."
}

• Service boundary analysis
• Data migration strategies
• API design for microservice
• Integration testing approach
• Rollback procedures

​

Use Case 8: Compliance and Audit Requirements

​

The Scenario

​

Without Architect API

• Manual documentation creation
• Inconsistent documentation standards
• Time-consuming audit preparation
• Risk of documentation gaps

​

With Architect API

• Automated comprehensive documentation
• Consistent structure and detail level
• Faster audit preparation
• Complete requirement traceability

​

Example: Healthcare Application Compliance

• Detailed audit trails specification
• Security control implementations
• Data encryption requirements
• Access control matrices
• Compliance testing procedures

• Faster compliance certification
• Reduced audit preparation time
• Consistent security implementation
• Clear regulatory requirement mapping

​

Common Patterns Across Use Cases

​

Iterative Development

​

Context Preservation

​

Team Alignment

​

Quality Assurance

​

Risk Management