MCAF

🥈Silver

MCAF is a framework for building software products with AI coding agents. It keeps all relevant context in a single repository, enabling teams to collaborate efficiently. MCAF integrates with AI agents like Claude, Codex, and Gemini to streamline software development workflows.

4970Updated 1mo ago

Intermediate30min to implementautomation

Saves ~60 min per use

Quick InstallView Source

git clone https://github.com/managedcode/MCAF.git

Works with:

Claude

Overview

About This Skill

MCAF is an innovative framework designed to facilitate the collaborative development of software products using AI coding agents. By leveraging this Claude Code skill, developers can streamline their coding processes, allowing AI agents to assist in generating code, debugging, and enhancing overall productivity. This automation skill is particularly beneficial for teams looking to integrate AI into their development workflows, making it easier to manage complex projects and accelerate delivery times. One of the key benefits of MCAF is its ability to reduce the time spent on repetitive coding tasks, enabling developers to focus on higher-level design and architecture. While the exact time savings are currently unknown, the framework's intermediate complexity suggests that teams can expect a significant boost in efficiency after a 30-minute implementation. This makes MCAF an attractive option for organizations aiming to optimize their workflow automation and enhance collaboration between human developers and AI agents. MCAF is particularly well-suited for developers, product managers, and AI practitioners who are looking to harness the power of AI in their software development processes. By integrating MCAF into their workflows, these professionals can take advantage of AI automation to improve code quality and reduce time-to-market for new features. Use cases for MCAF include building web applications, automating routine coding tasks, and enhancing existing software products with AI-driven functionalities. With an intermediate implementation difficulty, MCAF is accessible to those with a basic understanding of software development and AI principles. It seamlessly fits into AI-first workflows by enabling teams to collaborate with AI agents, thus transforming the way software products are built. As organizations increasingly adopt AI technologies, MCAF stands out as a valuable tool for enhancing productivity and fostering innovation in software development.

How to Use

1. **Initialize the Project**: Run `claude --mcaf init [PROJECT_NAME] --tech [TECH_STACK] --type [PROJECT_TYPE]` to generate the initial structure. For complex projects, use the `--modules` flag to specify required components. 2. **Customize the Framework**: Edit the generated `config.yaml` to match your team's standards. Set up your preferred AI agent integration in the `agents/` directory with API keys and model preferences. 3. **Develop with Context**: Use `claude --mcaf context [FILE_PATH]` to add relevant documentation, architecture diagrams, or past decisions to the MCAF repository. This ensures all AI agents have access to the same context. 4. **Iterate with Agents**: Run `claude --mcaf develop [TASK]` to have the AI agent implement features while referencing the project's context. Use `claude --mcaf review [PR_NUMBER]` to get automated code review suggestions based on your team's standards. 5. **Collaborate Efficiently**: Share the MCAF repository link with team members. Use the built-in discussion threads for design decisions, and reference specific commits in PR descriptions to maintain traceability. **Pro Tips:** - Store architecture decision records (ADRs) in the `docs/adr/` directory to maintain decision history - Use the `--include-tests` flag during scaffolding to generate test templates for your modules - For microservices, create separate MCAF repositories with a shared `shared/` directory for common libraries

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/managedcode/MCAF

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Use the MCAF framework to scaffold a [PROJECT_TYPE] project for [TECH_STACK]. Include best practices for [COLLABORATION_METHOD] (e.g., pair programming, code reviews). Generate a project structure with [MODULES] and set up [DEV_ENVIRONMENT] (e.g., Docker, virtualenv). Add placeholder code for [CORE_FUNCTIONALITY] and include a README.md with setup instructions. Use [AI_AGENT_NAME] as the primary coding assistant.

Example Output

## MCAF Project Scaffolding: E-Commerce API with FastAPI

**Project Structure:**
```
ecommerce-api/
├── src/
│   ├── models/
│   │   ├── user.py          # SQLAlchemy user model with password hashing
│   │   ├── product.py        # Product catalog model with inventory tracking
│   │   └── order.py          # Order model with status transitions
│   ├── schemas/
│   │   ├── user.py          # Pydantic schemas for request/response validation
│   │   ├── product.py        # Product DTOs with price validation
│   │   └── order.py          # Order creation and update schemas
│   ├── services/
│   │   ├── auth.py          # JWT token generation and verification
│   │   ├── payment.py        # Stripe integration for order processing
│   │   └── email.py          # SendGrid email service for order confirmations
│   ├── api/
│   │   ├── v1/
│   │   │   ├── users.py     # CRUD endpoints for user management
│   │   │   ├── products.py   # Product listing and search endpoints
│   │   │   └── orders.py     # Order creation and status tracking
│   └── core/
│       ├── config.py        # Environment-based configuration
│       └── database.py      # SQLAlchemy async session setup
├── tests/
│   ├── unit/
│   │   ├── test_user.py      # Unit tests for user service
│   │   └── test_product.py    # Product model validation tests
│   └── integration/
│       └── test_order.py     # Order processing workflow tests
├── Dockerfile                 # Multi-stage build for production
├── docker-compose.yml         # Local development stack (Postgres, Redis)
└── README.md                  # Setup, API docs, and deployment guide
```

**Core Functionality Implementation:**
```python
# src/api/v1/orders.py - Order creation endpoint
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from src.schemas.order import OrderCreate
from src.services.order import create_order

router = APIRouter(prefix="/orders", tags=["orders"])

@router.post("/", response_model=OrderCreate)
async def place_order(
    order_data: OrderCreate,
    session: AsyncSession = Depends(get_db)
):
    '''Create a new order with inventory check and payment processing'''
    try:
        order = await create_order(session, order_data)
        return order
    except InventoryError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except PaymentError as e:
        raise HTTPException(status_code=402, detail=str(e))
```

**Development Environment Setup:**
1. Clone the repository and run `docker-compose up -d` to start Postgres and Redis
2. Install pre-commit hooks: `pip install pre-commit && pre-commit install`
3. Create `.env` file with database URLs and API keys
4. Run migrations: `alembic upgrade head`

**Collaboration Guidelines:**
- Pair programming sessions should include at least one senior developer
- All PRs require approval from two team members before merging
- Code reviews focus on: security implications, performance bottlenecks, and edge cases
- Use GitHub Projects to track MCAF framework improvements