ECC
The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
- 307k
- JavaScript
- MIT
- 8 h ago
MCAF is a framework for building software products together with AI coding agents.
Repo managedcode/MCAF, read from GitHub 1 min ago. managedcode has not joined Take My Repo.
managedcode/MCAF is a public repo on GitHub by managedcode. MCAF is a framework for building software products together with AI coding agents. It declares the CC-BY-4.0 license on GitHub. It is written mainly in CSS, has 55 stars and last changed on 2026-10-11. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-20.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Managed Code Coding AI Framework
Developed and sustained by Managed Code
March 2026
MCAF is a framework for building real software with AI coding agents.
It defines how to:
AGENTS.md plus repo-native docs and skillsThe goal of MCAF:
Use AI to build real products in a way that is predictable, safe, and repeatable.
MCAF has three core elements:
AGENTS.md, and skills live with the repo.AGENTS.md files define how agents work here and learn over time.These concepts define the framework (the "what" and "why").
TUTORIAL.md is the bootstrap procedure (the "how").
Repository AGENTS.md files apply both to a specific solution.
v1.3 is skill-first.
Bootstrap stays minimal:
AGENTS.md templateCLAUDE.md wrapper templateCanonical install entry point:
Optional direct shortcuts:
Context is everything needed to understand, change, and run the system.
In MCAF, repository context includes:
AGENTS.mdAGENTS.md files for multi-project solutionsAnything that materially affects development, verification, or operation belongs in the repo.
A typical MCAF repo keeps durable docs under docs/:
docs/Architecture.md — global map and module boundariesdocs/Features/ — behaviour specs and testable flowsdocs/ADR/ — architecture decisions and trade-offsdocs/Testing/ — test strategy and environmentsdocs/Development/ — local setup and workflowsdocs/Operations/ — deployment, monitoring, and incident handlingThis is a reference layout, not a rigid folder law. The important part is that the repo has clear homes for architecture, behaviour, testing, development, and operations.
Public bootstrap templates are intentionally minimal:
docs/templates/AGENTS.mddocs/templates/CLAUDE.mdAuthoring scaffolds for architecture docs, feature specs, ADRs, governance, and maintainability do not live in docs/templates/.
They live in skills under references/ or assets/.
Skills are small, versioned workflow packs that make repetitive agent work predictable.
A skill contains:
SKILL.md — trigger metadata plus concise workflow instructionsreferences/ — long-form guidance or scaffolds loaded only when neededassets/ — output assets or templates used by the workflowscripts/ — deterministic helpers when they add reliabilityAGENTS.md owns the shared delivery workflow and approval rules. Skills contain only the guidance specific to their task; they do not repeat the Ralph Loop, generic planning advice, or a mandatory response schema. Load a reference only when its procedure or scaffold is needed. Keep existing skill names stable when tightening their contents so installed catalogs and links continue to work.
Recommended target locations in a consuming repo:
.codex/skills/.claude/skills/The public skill catalog lives on the Skills page:
Platform-specific bundles can stay small and still be explicit.
.NET skills are maintained outside this repository in the Managed Code Skills catalog.
Install the .NET skills you need from that catalog, then document the exact dotnet build, dotnet test, dotnet format, analyze, complexity, coverage, and other quality-gate commands in the consuming repo’s AGENTS.md.
For .NET code changes, the task is not done when tests are green if the repo also configured formatters, analyzers, complexity checks, coverage, architecture tests, or security gates.
Agents should run the repo-defined post-change quality pass before completion, and any external .NET helper should still include a Bootstrap When Missing section so agents can detect, install, verify, and first-run the tool without guessing.
The canonical contract is MCAF-ARCH-001.
MCAF-ARCH-001 is mandatory: one solution repository contains all solution-owned backend, frontend, contracts, tests, infrastructure, and documentation.docs/Architecture.md.docs/Features/.docs/Architecture.md contains Mermaid diagrams for system/module boundaries, interfaces/contracts, and key types for the active area.docs/Features/ contain at least one Mermaid diagram for the main flow.docs/ADR/ contain at least one Mermaid diagram for the decision and affected boundaries.AGENTS.md files.A vertical slice is one end-to-end business capability or use case, not one technical layer. A slice such as Orders owns its affected UI, API or backend behaviour, contracts, persistence or integrations, tests, infrastructure, and feature documentation.
In this policy, the solution is the complete product delivery boundary—not merely a .sln or .slnx file and not merely the backend. Its solution-owned frontend, backend, contracts, tests, infrastructure, and docs live and evolve together.
For an AI coding agent, the slice is the default unit of context and delivery. The agent starts from docs/Architecture.md, reads the applicable root and local AGENTS.md files, opens docs/Features/<SliceName>.md, and then works only in the matching slice paths. This lets the agent find the full behaviour without scanning the repository or guessing which generic service, controller, component, or test folder belongs to the feature.
The solution remains one repository, while toolchains may keep separate projects. Reuse the exact same slice name and internal convention across those roots:
src/Backend/Features/Orders/
src/Frontend/Features/Orders/
src/Contracts/Features/Orders/
tests/Features/Orders/
docs/Features/Orders.md
With this structure, a request such as "add order cancellation" has one deterministic scope: read the Orders feature doc and applicable governance, then update the affected Orders backend, frontend, contract, test, and documentation surfaces together.
Do not organize feature ownership primarily as repository-level Controllers/, Services/, Repositories/, Components/, or generic test buckets. Technical subfolders may exist inside a slice, but the business capability remains the owner.
To structure a solution:
<SliceName> naming and casing convention.Features/<SliceName>/ paths.AGENTS.md and docs/Architecture.md.docs/Features/<SliceName>.md behaviour and verification source for every feature.MCAF-REQ-001 makes requirements the input to architecture, agent tasks, code, and verification—not a prose artifact written afterward.
Every non-trivial docs/Features/<SliceName>.md contains:
REQ-* requirements with type, priority, rationale, and measurable pass/fail conditionsAC-* acceptance criteria and positive, negative, edge, and error flowsADR: N/A with a concrete reasonMCAF-AI-001 execution contract for non-trivial parallel workCreate an ADR before implementation when a feature changes boundaries, public contracts, data, dependencies, security, deployment topology, cross-cutting standards, or migration architecture. The ADR must include an executable implementation contract: ordered stages, exact slice/file ownership, dependencies, migration/rollout/rollback, agent roles, tests, pass conditions, and join evidence. Accepted means the decision is approved; Implemented means the implementation and verification evidence actually exist.
Canonical contract: MCAF-REQ-001.
Verification is how the team proves that behaviour and code quality meet expectations.
MCAF expects layered verification:
The goal is not “one test per feature.”
The goal is enough automated evidence to trust the change.
Integration tests are the backbone because they prove that a slice works through real boundaries, not just isolated units.
Under MCAF-REQ-001, non-trivial feature docs and architecture-affecting ADRs MUST point to:
REQ-*, AC-*, ADR, and TASK-* IDs that make the proof traceableInstructions define how AI agents behave in the repository and how they improve over time.
Every MCAF repo has a solution-root AGENTS.md.
In multi-project solutions, each project or module root also has a local AGENTS.md.
Root AGENTS.md owns:
Local AGENTS.md owns:
Agents follow this order:
AGENTS.md.AGENTS.md.Root AGENTS.md stays current with:
build, test, format, analyze, complexity, coverage, and other quality gates if used)MCAF-AI-001 model-tier routing: strongest suitable planning model, least expensive capable coding workers, required instruction packets, escalation, and lead reviewMCAF-REQ-001 feature requirements, ADR triggers and implementation contracts, plus traceability through tasks, tests, and evidence<slug>.brainstorm.md and <slug>.plan.md usageMCAF-ARCH-001 single-repository boundary and canonical vertical-slice path conventionAGENTS.md filesProject-local AGENTS.md files stay current with:
MCAF requires a Maintainability Limits section in AGENTS.md with stable keys:
file_max_loctype_max_locfunction_max_locmax_nesting_depthexception_policyThese values are repo policy, not framework constants.
MCAF may show starter values, but the active limits live only in the consuming repo’s AGENTS.md.
Chat is not memory.
Stable corrections, preferences, and recurring mistakes should become:
AGENTS.md rulesIf the same mistake happens twice, the framework expects the rule to be made durable. Self-learning is a cornerstone of the framework, not an optional habit.
MCAF-GOV-001 makes MCAF installation and updates merge-only: every existing root and local AGENTS.md rule stays mandatory and cannot be deleted, omitted, overwritten, summarized away, or weakened.AGENTS.md.AGENTS.md files at project roots.AGENTS.md before editing code.MCAF-ARCH-001 is mandatory: all solution-owned backend, frontend, contracts, tests, infrastructure, and docs stay in one repository.MCAF-AI-001 is mandatory for non-trivial work: the strongest suitable large or high-capability model available owns planning and final integration, while bounded coding scopes are spawned on the least expensive capable models.MCAF-REQ-001 is mandatory: non-trivial feature docs define stable REQ-*/AC-*; architecture-affecting ADRs define their implementation contract; every requirement traces through tasks, tests, and evidence.<slug>.brainstorm.md, then move into a root-level <slug>.plan.md.AGENTS.md, not in framework prose.Agents must use code inspection and reasoning from the outset. Read the implementation, callers, contracts, dependencies, tests, and docs needed for the whole approved task; think through success, failure, and edge paths. Deliver every accepted capability and required variant end to end. Do not substitute a simplified subset, leave in-scope wiring unfinished, or use repeated test runs to discover defects already visible in the code.
Before verification, review the complete implementation and tests against every accepted requirement, fix in-scope findings, and format the result. Tests must prove real flows and meaningful outcomes, cover required negative scenarios, and detect the intended regression. TDD and the Ralph Loop remain useful; every iteration and check needs a concrete purpose.
Obtain explicit user approval before introducing or replacing architecture, state ownership, serializers, serialization contracts, public APIs/events, database schemas, identity/trust boundaries, dependencies, or deployment topology, and before weakening quality or security gates. Present the concrete proposal, consequences, alternatives, migration/rollback, and verification plan. Prior approval remains valid for its exact scope. Routine bug fixes, wiring, local refactors preserving contracts and boundaries, tests, formatting, and docs proceed without renewed approval.
MCAF coding rules exist to keep systems changeable and testable.
MCAF-ARCH-001 makes the single-repository boundary and vertical-slice architecture mandatory for the complete solution.Controllers, Services, Repositories, or equivalent layer folders as the owners of feature behaviour.AGENTS.md.exception_policy.Meaningful literals are not scattered through the codebase.
Extract shared values into:
Hardcoded values are forbidden.
String literals do not belong in implementation logic. If a string matters, define it once as a named constant, enum value, configuration entry, or dedicated type and reference that symbol everywhere else.
AGENTS.md.MCAF describes responsibilities using four perspectives.
AGENTS.md currentAGENTS.mdHumans still own approval and merge decisions.
Before heavy coding:
For non-trivial work, start with a root-level <slug>.brainstorm.md and keep it concise.
The brainstorm records:
Brainstorm first, think through the task, then convert the chosen direction into a working plan. Do not create a brainstorm for simple, short, or obvious work where the path is already clear.
For non-trivial work, create a root-level <slug>.plan.md after the brainstorm direction is chosen, and keep it current.
The plan records:
Plan one verification phase after complete implementation, self-review of code and tests, fixes, and formatting. Use existing baseline evidence when available; run a pre-change baseline only when required or when it answers a specific question. Track discovered failures with their root cause and scope, and preserve required repository gates without turning unrelated failures into unauthorized repair work.
AGENTS.md to stay in scopeAfter reviewing code and tests and applying formatting, run the necessary layers in one planned phase:
Do not repeat passed checks without a new change, concrete failure, or unresolved question. Follow explicit instructions to run or defer checks and report the evidence and any remaining blockers accurately.
After implementation:
AGENTS.md or skills when rules or workflows changedMCAF supports three common AI participation modes.
The agent executes scoped work under current docs, skills, and AGENTS.md.
The agent and engineer iterate together on design, code, tests, and docs.
The agent reviews, critiques, or drafts options while humans retain implementation control.
For non-trivial implementation work, MCAF separates expensive reasoning from bounded code production:
The mandatory run protocol is:
MCAF-REQ-001 feature requirements and every required ADR implementation contractcomplete, blocked, failed, or cancelled states with evidence; idle and unverified summaries are not completionUse the runtime's available models, roles, permissions, and native spawn/status/message/wait controls. Exact model names and product commands are refreshable configuration. When configuring a platform, consult the current official Codex subagents, Claude Code parallel agents, Claude Code subagents, or Claude Code agent teams documentation as applicable.
Simple work does not require delegation when orchestration overhead exceeds the task. For non-trivial work, failure to delegate routine coding must have a concrete recorded reason such as unavailable model routing, insufficient worker capability, inseparable high-risk decisions, or unsafe ownership overlap.
The canonical contract is MCAF-AI-001.
The repo may choose different modes per task, but the same verification and governance rules still apply.
Use the tutorial as the canonical install flow:
AGENTS.md files using the governance skill.Adoption is complete when:
AGENTS.mdAGENTS.md<slug>.brainstorm.md, <slug>.plan.md, and the Ralph LoopMCAF-ARCH-001 is recorded in AGENTS.md and docs/Architecture.md, with all solution-owned surfaces in one repository and a consistent repo-wide slice mapMCAF-GOV-001 is enforced: framework updates preserve every existing root and local AGENTS.md rule and keep the stricter formulation on overlapMCAF-AI-001 is enforced: strong models plan and review non-trivial work, while bounded coding is delegated to cheaper capable models with explicit instructionsMCAF-REQ-001 is enforced: non-trivial features have stable requirements and acceptance criteria, required ADRs have implementation contracts, and requirements trace through tasks, tests, and evidencemanagedcode/MCAF is a public repo on GitHub by managedcode. MCAF is a framework for building software products together with AI coding agents.
It declares the CC-BY-4.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-10-11. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

Reverse engineer anything with agents, from app behavior down to native binaries.
Pocket Flow: 100-line LLM framework. Let Agents build Agents!

One of the largest .NET-focused skill collections for AI coding assistants, with a catalog, CLI, and orchestration agents for Codex, Claude Code, GitHub Copilot, Gemini, and Junie.

Storage library provides a universal interface for accessing and manipulating data in different cloud blob storage providers
Result pattern for .NET that replaces exceptions with type-safe return values. Features railway-oriented programming, ASP.NET Core integration, RFC 7807 Problem Details, and built-in pagination. Designed for production systems requiring explicit error handling without the overhead of throwing exceptions.

Browser-first teleprompter, rehearsal, and live presentation studio built with .NET 10 and Blazor WebAssembly.
Orleans.SignalR is a lightweight, open-source library that enables easy integration of SignalR with Orleans, a distributed virtual actor model framework for building scalable, fault-tolerant systems. The library provides a SignalR backplane, allowing you to effortlessly add real-time communication capabilities to your distributed systems.
This is a library for Microsoft Orleans that provides a set of rate limiting algorithms for controlling the flow of requests in your distributed applications. It is designed to be easy to use and to integrate with your Orleans-based applications seamlessly.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/managedcode/MCAFTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.