AI Dev Framework: Complete User Guide

Overview

The AI Dev Framework is a comprehensive solution that combines project scaffolding automation with intelligent AI workflow agents to accelerate software development from initial requirements to implementation. This framework reduces project setup time from 5-9 hours to under 10 minutes and provides specialized AI agents to guide you through the entire software development lifecycle.

The framework consists of two main components:

1. AI Dev Framework CLI - A powerful scaffolding tool that generates production-ready project structures with AI tool integration
2. AI Workflow Agents - Specialized agents that guide you through requirements analysis, architecture design, planning, and implementation

Key Framework Principles:

• Layered Development - Agents work on one application layer at a time (frontend or backend), ensuring focused, high-quality development
• Systematic Integration - Dedicated integration agents connect frontend and backend applications seamlessly
• Quality-First Approach - Built-in validation and auditing at every phase of development
• Full Lifecycle Coverage - From business requirements to deployed code, the framework supports every step

Table of Contents

• Getting Started with the CLI
• Project Scaffolding
• AI Workflow Agents
• Complete Workflow Example
  • Phase 1: Initial Setup and Scaffolding
  • Phase 2: Requirements Analysis
  • Phase 3: Architecture and Design
  • Phase 4: Implementation Planning
  • Phase 5: Integration with GitHub and Jira
  • Phase 6: Frontend Implementation
  • Phase 7: Backend Implementation
  • Phase 8: Frontend-Backend Integration
  • Phase 9: Iteration and Expansion
• Best Practices
• Additional Resources

Getting Started with the CLI

Repository Setup

Begin your journey with the AI Dev Framework by cloning the repository and setting it up locally. This gives you access to both the scaffolding CLI and the comprehensive suite of AI workflow agents.

# Clone the repository
git clone https://github.com/your-org/ai-dev-framework.git

# Open the cloned repository in VS Code
cd ai-dev-framework
code .

# Switch to the feature/workflow-agents branch
git checkout feature/workflow-agents

# Navigate to the framework directory
cd framework

# Install dependencies
npm install

# Link the CLI globally (optional, for global access)
npm link

Local Configuration

Once installed, the framework is ready to use. The CLI includes an interactive wizard that walks you through configuration, so no manual setup is required. However, if you need to customize default behaviors, you can create a .adf-config.json file in your home directory with your preferred defaults.

Project Scaffolding

The AI Dev Framework CLI generates complete, production-ready project structures tailored to your specific needs. Through an interactive 5-step wizard, you'll define your project type, technology stack, AI tool integrations, and development methodologies.

Creating a New Project

To scaffold a new project, simply run the CLI command:

# If globally installed
ai-dev-framework init

# Or from the framework directory
npm start

The Scaffolding Wizard

The wizard guides you through five key configuration steps:

1. Project Basics - Define project name, type (greenfield/brownfield/migration), description, and output directory
2. Technology Stack - Select your backend language, frontend framework, database, testing tools, and architectural pattern
3. AI Tools - Choose which AI development tools to integrate (Claude Code, GitHub Copilot, Cursor, or any combination)
4. Methodologies - Optionally integrate BMAD, Human Layer, and/or Superpowers methodologies
5. Advanced Configuration - Fine-tune agent configurations, MCP servers, skills, and commands

Example: Scaffolding a React Project

For a modern React application with Node.js backend, you would select:

• Project Type: Greenfield
• Backend: Node.js with Express
• Frontend: React (with TypeScript)
• Database: PostgreSQL or MongoDB
• AI Tools: Claude Code and GitHub Copilot
• Architecture: Microservices or Monolithic (based on your needs)

The framework generates a complete project structure including:

• Organized folder hierarchy (src/, tests/, docs/, etc.)
• AI tool configurations (.claude/, copilot-instructions.md)
• 11+ specialized AI agents for different roles
• 20+ SDLC skills for requirements, design, implementation, and testing
• Comprehensive documentation and onboarding guides
• Pre-configured MCP servers for enhanced AI capabilities
• Boilerplate code, test setups, and configuration files

What you get in under 10 minutes:

• Complete folder structure aligned with best practices
• All AI tools pre-configured and ready to use
• Specialized agents for every phase of development
• Skills library for common development tasks
• Documentation templates and guides
• Error recovery and progress tracking built-in

AI Workflow Agents

After scaffolding your project, the real power of the framework comes from its specialized AI workflow agents. These agents guide you through a structured development process, from requirements to implementation.

Available Workflow Agents

The framework includes 12 specialized agents organized by their role in the development lifecycle:

Requirements & Analysis Agents

1. BRD Analyzer Agent (BA_ANALYZER_AGENT) - Analyzes Business Requirement Documents to extract functional and non-functional requirements
2. Quality Auditor Agent (QUALITY_AUDITOR_AGENT) - Reviews and validates all generated artifacts for completeness and quality

Architecture & Design Agents

3. Architect Agent (ARCHITECT_AGENT) - Designs comprehensive system architecture based on requirements
4. Architecture Validator Agent (ARCH_VALIDATOR_AGENT) - Validates architectural decisions against best practices

Planning Agents

5. Implementation Planner Agent (IMPLEMENTATION_PLANNER_AGENT) - Creates detailed implementation plans with task breakdowns

Integration Agents

6. Integration Planning Agent (INTEGRATION_PLANNING_AGENT) - Plans system integrations, API contracts, and data flow between frontend and backend
7. Integration Execution Agent (INTEGRATION_EXECUTION_AGENT) - Executes integration implementations, connecting frontend to backend services
8. Integration Verifier Agent (INTEGRATION_VERIFIER_AGENT) - Validates integration implementations and tests end-to-end flows

Project Management Agents

9. Jira Ticket Generator (JIRA_TICKET_GENERATOR_AGENT) - Generates Jira tickets from implementation plans
10. Jira Validator Agent (JIRA_VALIDATOR_AGENT) - Validates Jira ticket structure and completeness
11. Jira Uploader Agent (JiraUploader) - Uploads generated tickets to Jira

Implementation Agent

12. Task Executor Agent (TASK_EXECUTOR_AGENT) - Executes specific development tasks for frontend or backend development

Using the Agents

Each agent is defined in the agents/ directory of your scaffolded project. To use an agent in Claude Code or other AI tools:

1. Reference the agent in your prompt (e.g., "@BA_ANALYZER_AGENT analyze this BRD")
2. Provide the necessary context (documents, requirements, etc.)
3. Review the agent's output
4. Proceed to the next agent in the workflow

Agent Workflow Sequence

Here's the recommended sequence for using agents in a typical project:

| Phase | Agent | Purpose | Input | Output | |-------|-------|---------|-------|--------| | Analysis | BRD Analyzer | Extract requirements | Business Requirements Document | Requirements list, user stories | | Validation | Quality Auditor | Validate requirements | BRD analysis artifacts | Quality report, gaps identified | | Design | Architect | Design system | Requirements + constraints | Architecture design document | | Validation | Architecture Validator | Validate design | Architecture design | Validation report | | Planning | Implementation Planner | Create implementation plan | Architecture design | Task breakdown, sprint plan | | PM Setup | Jira Ticket Generator | Generate tickets | Implementation plan | Jira ticket definitions | | Validation | Jira Validator | Validate tickets | Generated tickets | Validation report | | PM Setup | Jira Uploader | Upload to Jira | Validated tickets | Jira board populated | | Development | Task Executor | Build frontend | Jira user story | Frontend components + tests | | Validation | Quality Auditor | Review frontend | Frontend code | Quality report | | Development | Task Executor | Build backend | Jira user story | Backend APIs + tests | | Validation | Quality Auditor | Review backend | Backend code | Quality report | | Integration | Integration Planning | Plan integration | Frontend + backend specs | Integration plan | | Integration | Integration Execution | Connect layers | Integration plan | Integrated application | | Integration | Integration Verifier | Test integration | Integrated application | Integration test report | | Final Review | Quality Auditor | Final audit | Complete feature | Final quality report |

Complete Workflow Example

Here's a complete workflow demonstrating how to use the AI Dev Framework from initial setup through implementation:

Phase 1: Initial Setup and Scaffolding

Start by setting up your development environment and creating your project structure.

Step 1: Clone and Configure the Framework

git clone https://github.com/durgeshpiogc321/ai-dev-framework.git
cd ai-dev-framework
code .
git checkout feature/workflow-agents
cd framework
npm install
npm link

Step 2: Scaffold Your Project

Run the interactive wizard to create your project structure. For this example, we'll create a React-based web application:

ai-dev-framework init

Select the following options when prompted:

• Project type: Greenfield
• Project name: my-awesome-app
• Backend: Node.js
• Frontend: React
• AI Tools: Claude Code + GitHub Copilot
• Methodologies: BMAD (recommended for structured workflows)

Within minutes, you'll have a complete project structure with all AI tools configured and ready to use.

Phase 2: Requirements Analysis

With your project scaffolded, begin by analyzing your business requirements.

Step 3: Add Your BRD

Create or copy your Business Requirements Document into your project's docs/requirements/ directory. This document should contain your project's goals, user stories, functional requirements, and non-functional requirements.

Step 4: Analyze with BRD Analyzer Agent

Open Claude Code or your preferred AI tool and reference the BRD Analyzer Agent:

@BA_ANALYZER_AGENT Please analyze the BRD document in BRD/Example-BRD.md.

The agent will generate a comprehensive analysis including:

• Extracted user stories
• Functional requirements list
• Non-functional requirements (performance, security, scalability)
• Identified constraints and dependencies
• Suggested clarifications or missing information

Step 5: Quality Audit

Before proceeding, validate the analysis with the Quality Auditor Agent:

@QUALITY_AUDITOR_AGENT Please review all artifacts generated by the BRD Analyzer and verify completeness, consistency, and quality.

The auditor will identify any gaps, inconsistencies, or areas requiring additional detail.

Phase 3: Architecture and Design

With validated requirements, design your system architecture.

Step 6: Create System Architecture

Engage the Architect Agent to design your solution:

@ARCHITECT_AGENT Based on the analyzed requirements, please design a comprehensive system architecture including component diagrams, data models, and technology stack decisions.

The architect will produce:

• High-level system architecture
• Component interaction diagrams
• Database schema design
• API contract specifications
• Technology stack recommendations
• Security architecture
• Deployment architecture

Step 7: Validate Architecture

Use the Architecture Validator Agent to ensure the design meets best practices:

@ARCH_VALIDATOR_AGENT Please validate the proposed architecture against industry best practices, scalability requirements, security standards and the BRD.

Phase 4: Implementation Planning

Transform your architecture into an actionable implementation plan.

Step 8: Generate Implementation Plan

Leverage the Implementation Planner Agent:

@IMPLEMENTATION_PLANNER_AGENT Create a detailed implementation plan with task 
breakdown, dependencies, and estimated efforts based on the approved architecture.

The planner generates:

• Module breakdown
• Task dependencies
• Sprint planning suggestions
• Resource requirements
• Risk assessment
• Implementation timeline

Phase 5: Integration with GitHub and Jira

Before generating tickets, set up your project management and version control integration.

Step 9: GitHub Repository Setup

Create two separate repositories for your project:

1. Frontend Repository - Contains the UI application, integration logic, end-to-end tests, and deployment configurations
2. Backend Repository - Contains the API, business logic, and API documentation

Why Two Repositories?

• Independent Development - Frontend and backend teams can work independently
• Clear Ownership - Different teams can own different repos
• Simplified CI/CD - Each repo has its own focused build and deployment pipeline
• Better Security - Apply different access controls to each layer
• Scalability - Scale infrastructure independently for frontend and backend
• Frontend-Centric Integration - Integration logic lives in the frontend where API consumption happens

Creating the Repositories:

# 1. Create Frontend Repository
gh repo create my-awesome-app-frontend --private --description "Frontend application for My Awesome App"

# Navigate to frontend directory and initialize git
cd my-awesome-app/frontend
git init
git add .
git commit -m "Initial frontend scaffold from AI Dev Framework"
git branch -M main
git remote add origin https://github.com/your-username/my-awesome-app-frontend.git
git push -u origin main
cd ..

# 2. Create Backend Repository
gh repo create my-awesome-app-backend --private --description "Backend API for My Awesome App"

# Navigate to backend directory and initialize git
cd backend
git init
git add .
git commit -m "Initial backend scaffold from AI Dev Framework"
git branch -M main
git remote add origin https://github.com/your-username/my-awesome-app-backend.git
git push -u origin main
cd ..

Repository Structure Overview:

my-awesome-app-frontend/          (Repository 1 - Frontend)
├── src/
│   ├── components/
│   ├── services/        # API client services
│   ├── pages/
│   └── utils/
├── tests/
│   ├── unit/
│   ├── integration/     # Frontend-backend integration tests
│   └── e2e/             # End-to-end tests
├── api-docs/            # Backend API documentation (Swagger/OpenAPI)
├── deployment/
│   ├── docker-compose.yml
│   ├── kubernetes/
│   └── nginx.conf
├── docs/
│   ├── architecture/
│   ├── integration/
│   └── deployment/
├── package.json
└── .github/workflows/

my-awesome-app-backend/           (Repository 2 - Backend)
├── src/
│   ├── controllers/
│   ├── services/
│   ├── models/
│   └── routes/
├── tests/
│   ├── unit/
│   └── integration/
├── docs/
│   ├── api/             # API documentation source
│   ├── architecture/
│   └── database/
├── swagger/             # Swagger/OpenAPI specification
├── package.json
└── .github/workflows/

Step 10: Jira Board Setup

1. Create a new Jira project for your application
2. Configure appropriate workflows (e.g., To Do, In Progress, Review, Done)
3. Set up issue types (Epic, Story, Task, Bug)
4. Generate a Jira API token:
   • Go to Jira Profile → Account Settings → Security → API Tokens
   • Create a new API token
   • Save the token securely

Step 11: Configure Integration Settings

Create a configuration file in your frontend repository at .config/integrations.json:

{
  "github": {
    "frontend": {
      "owner": "your-username",
      "repo": "my-awesome-app-frontend",
      "token": "your-github-token"
    },
    "backend": {
      "owner": "your-username",
      "repo": "my-awesome-app-backend",
      "token": "your-github-token"
    }
  },
  "jira": {
    "host": "your-company.atlassian.net",
    "email": "[email protected]",
    "apiToken": "your-jira-api-token",
    "projectKey": "MAA"
  },
  "backend": {
    "apiBaseUrl": "http://localhost:3000/api",
    "apiDocsPath": "./api-docs/swagger.json"
  }
}

Important: Add .config/integrations.json to your .gitignore to prevent committing sensitive tokens.

Step 12: Generate Jira Tickets

Use the Jira Ticket Generator Agent:

@JIRA_TICKET_GENERATOR_AGENT Generate Jira tickets from the implementation plan, organizing them into epics and stories.

The agent creates structured Jira ticket definitions with:

• Epics for major features
• User stories linked to epics
• Tasks with acceptance criteria
• Story points and labels
• Dependencies and relationships

Step 13: Validate Tickets

Before uploading, validate the ticket structure:

@JIRA_VALIDATOR_AGENT Please validate all generated Jira tickets for completeness, proper structure, and correct relationships.

Step 14: Upload to Jira

Finally, upload the validated tickets:

@JiraUploader Upload all validated tickets to Jira using the configured 
integration settings.

Phase 6: Frontend Implementation

Begin actual development with AI-assisted task execution. Note that the framework's agents work on one application layer at a time (frontend or backend), allowing for focused, quality development.

Step 15: Implement Frontend Module (UI with Mock Data)

Start by implementing the first UI module with mock data using the Task Executor Agent:

@TASK_EXECUTOR_AGENT Fetch the first frontend user story from the Jira board 
and implement exactly what the user story describes. Create the UI components 
with mock data for demonstration. Ask me if you have any questions.

The Task Executor Agent will:

• Generate component files with proper structure
• Create mock data services
• Implement responsive layouts
• Write unit tests
• Follow your project's established patterns and conventions

Phase 7: Backend Implementation

Following the same systematic approach used for frontend development, now build the backend application layer.

Step 16: Develop Backend Application

Using the above same steps develop the Backend application separately.

Phase 8: Frontend-Backend Integration

With both frontend and backend implementations complete, use the specialized integration agents in your frontend repository to connect them seamlessly.

Step 17: Obtain Backend API Documentation

The backend team provides API documentation (typically Swagger/OpenAPI specification) which should be placed in the frontend repository:

# In your frontend repository
mkdir -p api-docs

# Backend team provides swagger.json or openapi.yaml
# Copy it to frontend/api-docs/
cp path/to/backend/swagger/swagger.json api-docs/

Step 18: Plan Integration Strategy

Engage the Integration Planning Agent (in frontend repo) to create an integration plan using the backend API documentation:

@INTEGRATION_PLANNING_AGENT Using the backend API documentation in api-docs/swagger.json,
create a detailed integration plan covering:
- API endpoint mapping for each frontend feature
- Data flow mapping between UI components and backend APIs
- Request/response data transformations
- Error handling strategy for API failures
- Authentication token handling and refresh logic
- State management approach for API data
- Integration test scenarios

The Integration Planning Agent will produce:

• API endpoint mapping (frontend features → backend endpoints)
• Request/response payload transformations
• Authentication flow implementation plan
• Error handling patterns for network and API errors
• Integration testing checklist
• Environment configuration requirements

Step 19: Execute Integration

Use the Integration Execution Agent (in frontend repo) to implement the integration:

@INTEGRATION_EXECUTION_AGENT Execute the integration plan by:
- Replacing mock data services with actual API calls based on api-docs/swagger.json
- Implementing HTTP client configuration (axios/fetch)
- Adding authentication headers and token management
- Implementing error handling and retry logic
- Setting up environment-based API endpoint configuration
- Creating API service layer following the integration plan

The Integration Execution Agent will:

• Remove or replace mock data services with real API clients
• Implement API service classes/functions per the plan
• Configure HTTP interceptors for authentication and error handling
• Add loading states and error boundaries in components
• Implement data caching strategies if needed
• Set up environment variables for API endpoints (.env files)
• Create type definitions based on API contracts

Step 20: Verify Integration

Use the Integration Verifier Agent (in frontend repo) to validate the integration:

@INTEGRATION_VERIFIER_AGENT Verify the frontend-backend integration by:
- Testing all implemented API endpoints from the frontend
- Validating data flow matches the API documentation
- Checking error scenarios (network failures, 4xx/5xx errors, timeouts)
- Verifying authentication and authorization flows
- Running the integration test suite
- Performance testing API response times
- Confirming API contracts match implementation

The Integration Verifier Agent will:

• Execute integration tests against the real backend
• Verify API responses match Swagger/OpenAPI specification
• Test error scenarios (network failures, timeouts, 4xx/5xx responses)
• Validate authentication token handling and refresh
• Check data consistency between frontend state and backend data
• Measure response times and identify performance bottlenecks
• Generate comprehensive integration test report
• Confirm all acceptance criteria are met

Phase 9: Iteration and Expansion

With the first module successfully implemented and integrated, continue the cycle for remaining features:

1. Select Next Story - Pick the next priority story from your Jira board
2. Implement Backend APIs - Use Task Executor Agent to build APIs and update Swagger docs
3. Update API Documentation - Backend team shares updated swagger.json with frontend team
4. Implement Frontend - Use Task Executor Agent for UI components with mock data
5. Integrate - Use Integration agents (Planning → Execution → Verifier) in frontend repo (Steps 17-20)
6. Validate - Quality audit the complete feature
7. Deploy - Move to staging/production environments
8. Repeat - Continue with the next story

This iterative approach ensures:

• Each feature is fully complete (frontend + backend + integration)
• Quality is maintained through continuous auditing
• Progress is trackable and manageable
• Issues are caught early in small increments
• The application remains in a deployable state

Best Practices

Workflow Recommendations

1. Always start with requirements analysis - Use the BRD Analyzer Agent before jumping into architecture or code
2. Validate at each phase - Use the Quality Auditor Agent after major artifact generation
3. Document decisions - Keep the generated architecture and planning documents updated
4. Use incremental implementation - Start with core modules and expand iteratively
5. Leverage mock data early - Create UI mockups with mock data to validate design before backend integration
6. Develop frontend and backend separately - Focus on one layer at a time for better quality and clarity
7. Plan integration before execution - Always use the Integration Planning Agent before connecting frontend and backend
8. Test at every layer - Unit tests for components, integration tests for APIs, end-to-end tests for complete flows
9. Keep applications deployable - Ensure each iteration leaves the application in a working, deployable state
10. Use version control consistently - Commit after each completed feature (frontend, backend, and integration)

• Use two repositories - Maintain separate repos for frontend and backend for clean separation of concerns and independent deployment cycles

Frontend-Backend Development Workflow

The framework agents work on one application layer at a time, which provides several advantages:

• Focused Development - Concentrate on frontend or backend concerns without context switching
• Parallel Work Potential - Different team members can work on frontend and backend simultaneously
• Better Testing - Test each layer independently before integration
• Clearer Separation - Maintain clean architectural boundaries
• Easier Debugging - Isolate issues to specific layers

Recommended Sequence:

1. Implement frontend with mock data first (allows early UI/UX validation)
2. Develop backend APIs with proper contracts
3. Plan integration strategy carefully
4. Execute integration systematically
5. Verify integration thoroughly

Alternatively, for API-first approaches:

1. Develop backend APIs and services first
2. Create frontend consuming the real APIs
3. Use integration agents to validate and optimize the connection

Repository Organization Strategy

The AI Dev Framework uses a two-repository architecture for optimal code organization and deployment flexibility.

The Two-Repository Structure:

1. Frontend Repository - UI application, integration logic, E2E tests, and deployment configurations
2. Backend Repository - API, business logic, and API documentation

Why Two-Repository Architecture?

• Independent Development - Frontend and backend teams work independently
• Clear Ownership - Different teams can own different repositories
• Simplified CI/CD - Each repo has its own focused build and deployment pipeline
• Better Security - Apply different access controls to each layer
• Scalability - Scale teams and infrastructure independently
• Frontend-Centric Integration - Integration logic lives where API consumption happens
• Focused Codebases - Smaller, more maintainable repositories

Benefits:

• Clear ownership and responsibility boundaries
• Independent versioning and release cycles
• Easier to scale teams and infrastructure independently
• Better security through isolated access controls
• Faster build times per repository
• Frontend owns the integration and testing of API consumption

Frontend Repository Contains:

• UI components and pages
• API client services (integration with backend)
• End-to-end integration tests
• Deployment configurations (Dockerfile, docker-compose, K8s manifests)
• Backend API documentation (in api-docs/ folder)
• Integration test suites
• Environment configurations

Backend Repository Contains:

• API endpoints and controllers
• Business logic and services
• Database models and migrations
• API documentation source (Swagger/OpenAPI)
• Backend unit and integration tests
• Backend deployment configurations

Integration Best Practices

When using the Integration agents (all located in the frontend repository):

• Keep API docs updated - Backend team must share updated Swagger/OpenAPI specs in frontend's api-docs/ folder
• Define contracts early - Establish clear API contracts before implementation begins
• Version your APIs - Use API versioning to manage changes and maintain backward compatibility
• Frontend owns integration - All integration logic, tests, and verification happen in the frontend repo
• Use the 3-agent workflow - Always follow Planning → Execution → Verification sequence
• Handle errors gracefully - Implement comprehensive error handling at integration points
• Use environment configs - Maintain separate API base URLs for development, staging, and production
• Mock during development - Use mock data while backend APIs are being developed
• Test with real backend - Integration Verifier tests against actual backend services
• Monitor integration points - Add logging and monitoring at all API call points
• Test failure scenarios - Verify behavior during network failures, timeouts, and error responses
• Document integration patterns - Keep integration plans and reports in frontend's docs/integration/

Agent Usage Tips

• Be specific in prompts - Provide clear context and expected outcomes when engaging agents
• Review agent outputs - Always review and validate agent-generated artifacts before proceeding
• Iterate as needed - Don't hesitate to ask agents to refine or regenerate outputs
• Maintain consistency - Keep all generated documents in the project's docs/ directory for easy reference
• Use appropriate agents - Task Executor for implementation, Integration agents for connecting layers
• Provide Jira context - Reference specific Jira tickets when asking agents to implement features
• Include acceptance criteria - Share user story acceptance criteria to help agents understand requirements fully

Security Considerations

• Never commit tokens - Always add integration configuration files to .gitignore
• Use environment variables - Store sensitive data in environment variables or secure vaults
• Rotate tokens regularly - Periodically regenerate API tokens for GitHub and Jira
• Review generated code - Always review agent-generated code for security vulnerabilities before committing

Additional Resources

Documentation

• Framework CLI Documentation - Detailed CLI usage and configuration options
• Integration Agents Overview - Deep dive into integration agents
• Integration Agents User Guide - Step-by-step integration workflow
• Project Scope Guide - Understanding project types and scopes
• Contributing Guide - How to contribute to the framework

Quick Links

• npm Package: https://www.npmjs.com/package/ai-dev-framework
• GitHub Repository: https://github.com/your-org/ai-dev-framework
• Issue Tracker: https://github.com/your-org/ai-dev-framework/issues
• Discussions: https://github.com/your-org/ai-dev-framework/discussions

Support

For questions, issues, or feature requests:

1. Check the documentation first
2. Search existing issues
3. Open a new issue with detailed information
4. Join our community discussions

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

The AI Dev Framework builds upon methodologies and patterns from:

• BMAD (Business Methodology for AI Development)
• Human Layer - Human-in-the-loop AI development patterns
• Superpowers - Enhanced AI development capabilities

Special thanks to all contributors who have helped shape this framework.

Ready to accelerate your development workflow?

Get started now:

npx ai-dev-framework init

Transform hours of setup into minutes of configuration, and leverage intelligent AI agents to guide you from requirements to working code.