What is Meta-Architect?

When we talk about AI coding agents, most tools are great at “fill in this function” and pretty weak at “is this system actually well-designed?”.

Meta-Architect is live on GitHub.
Repo link: https://github.com/JustineDevs/meta-architect

What Meta-Architect is (and isn’t)
Meta-Architect:
runs as skills inside Codex
ships as a package/plugin, not a new shell
tries to help with architecture, not just local code edits
It’s designed to plug into the Codex ecosystem rather than competing with it.

Here is what you get.

What Meta-Architect is
Meta-Architect gives your AI agents a real architecture workflow, not loose prompts.

You get six named roles with strict responsibilities.

• \$arch designs the system and explains the stack
• \$sage pulls proven OSS patterns and libraries
• \$flow maps user flows, state, and edge cases
• \$vet reviews security and stops unsafe builds
• \$vibe reviews developer experience and user experience
• \$build turns the approved plan into an execution roadmap

Each role is a skill with a clear contract.

How it fits into your workflow

The idea is not to replace your existing tools.
Instead, Meta-Architect gives you a set of skills you can call when you need to:
understand the shape of a system
explore alternative designs
identify weak boundaries and risky assumptions
turn requirements into more structured plans
You stay inside Codex; Meta-Architect just adds a set of focused capabilities on top.

Why this exists
Most AI dev tools feel helpful at first, then fall apart when you try to ship.

• They hallucinate stacks that never reach production
• They ignore architecture, security, and release gates
• They treat your repo as plain text instead of a system with rules and states

Meta-Architect goes the other way.
You treat the repo as the source of truth for skills, prompts, gates, packaging, and CI from v0.1.0 onward.

What lives in the repo
You are not downloading a bag of prompts.
You are getting a shaped repository.

Skills

• skills/meta-architect-*.md holds the core skills for Arch, Sage, Flow, Vet, Vibe, Build
• each skill defines a trigger, responsibilities, expected outputs, and gate impact

Prompts

• stable role prompts for Architect, Sage, Flow, Security Reviewer, Builder, and others
• written as contracts so your agents keep the same behavior across sessions

Templates

• templates/AGENTS.md defines how triggers, gates, and evidence should behave together
• templates/catalog-manifest.json is the catalog for skills and prompts

Missions

• scenario folders like collaborative whiteboard, fintech app, SaaS dashboard
• each mission describes constraints, expected gate changes, and what artifacts you should see

Plugin and publishing

• plugins/meta-architect provides a bundle you can install as a plugin in compatible runtimes
• scripts and npm commands handle skills:manifest, skills:validate, skills:pack, skills:install

Repo discipline

• CONTRIBUTING plus issue forms keep contributions aligned with release safety
• CI workflows run skills manifest, validate, pack, and install on each change
• release and npm publish workflows treat your skills as versioned artifacts
• checks prevent .omx runtime state from leaking into git

How you use this on a real project
Say your idea is:
“I want an AI powered smart contract security review workspace for solo founders.”

You run the skills in this order.

• \$arch gives you system boundaries, stack choices, and clear risks
• \$sage finds frameworks, auth, and infra from curated OSS lists
• \$flow maps user journeys, data flow, and failure paths
• \$vet reviews security and stops the build if status is not GREEN
• \$vibe reviews onboarding, complexity, and usability
• \$build turns the approved plan into repo layout, environment setup, and v0.1.0 milestones

You move from idea to gated plan in a repeatable way.

Who this helps
For developers

• You keep control of architecture while offloading repetitive design work
• You get a build plan that respects security and release practice

For new architects

• You see how decisions, patterns, trade offs, and gates connect
• You get concrete examples instead of vague theory

For experienced architects

Why share this now?
This release is “ready enough” for people who actually want to use it in anger and tell me where it breaks:
architecture folks who want more structure around design discussions
engineers experimenting with AI-assisted reviews or design sessions
anyone tired of manually repeating “here’s how our system works…” to an LLM
If you want to kick the tires:
👉 https://github.com/JustineDevs/meta-architect

• You get a checklist that encodes your process into skills and CI
• You can standardize how teams and agents reason about architecture

For maintainers and tool builders

• You start from a repo pattern that already has skills, prompts, missions, MCP config, CI, and plugin bundling
• You can adapt this pattern for your own skills library

What comes next
Near term work

• Make the Architect skill behave like a small architecture handbook
• Expand missions with deeper real world scenarios
• Improve docs for skills publishing and MCP setup
• Wire this into Codex style workflows so agents help maintain the repo under gates

Longer term work

• Turn Meta-Architect into a base template for new repos that want AI aware architecture from day one

If this is the type of discipline you want around your AI workflows, review the repo, open an issue, or start a fork.
Repo link again: https://github.com/JustineDevs/meta-architect