TaiyiForge
Dong90/oh-my-taiyiforge
Fluxo de R&D com gates, não vibes — nove fases, um comando.
Ver no GitHubMotor de fluxo de trabalho R&D em IA que orquestra seis padrões de engenharia em nove estágios executáveis, com gates obrigatórios para cada fase. Transforma requisição → design → desenvolvimento → teste → review → arquivo em um contrato de artefatos auditável, integrando Harness, OpenSpec, GStack e outras standards numa única máquina de estados.
Instalação
npx convez-ai Dong90/oh-my-taiyiforge1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Orquestração de workflows R&D em equipes usando Claude, OpenCode ou Codex
- Garantir completude de documentação (REQUIREMENT, DESIGN, CHANGE) antes de código
- Auditoria de artefatos intermediários com rastreamento de contexto compacto
- Sincronização de fluxos de trabalho entre múltiplas plataformas de IA
Veredito

Ferramenta robusta e opinada para equipes que precisam de rigor processual em workflows de IA. Resolve o problema real de agentes que pulam fases, mas exige disciplina organizacional para adoção — não é para prototipação rápida.
README
A tradução para o português deste README ainda está na fila.
TaiyiForge
Turn six AI engineering standards into a single executable nine-stage R&D workflow
Document-driven AI R&D with gates, not vibes.
Stop memorizing the phase order. Say
/taiyi:newand the engine tells you what's next.
Quick Start · Usage Guide · Architecture · Command Reference · Full Flow · Contributing

4K visual poster (non-technical source) · Editable source: SVG · C4
TL;DR (30 seconds)

27-second real terminal recording · asciicast source (playable on asciinema.org or locally with asciinema play docs/diagrams/demo.cast)
- What it is: An AI R&D workflow engine that turns "requirement → design → dev → test → review → archive" into a nine-stage artifact contract, plus 23
taiyi-*Skills. - Who it's for: Teams and individuals using OpenCode / Claude / Codex / Cursor for serious projects (medium-or-larger, with review, with delivery gates).
- How to use it: In your project, run
taiyi new "feature name". The engine guides you to writeCHANGE.md/REQUIREMENT.md/DESIGN.md… All nine stages complete, every intermediate artifact is auditable. - Why not another standard: TaiyiForge does not invent standards — it orchestrates Harness · OpenSpec · GStack · Superpowers · OMO · Spec-Kit into one state machine. Use what you have installed; everything else is auto-skipped as optional.
Why TaiyiForge?
| Pain you've hit | TaiyiForge's answer |
|---|---|
| Agent forgets the phase order mid-task and jumps to code | Previous stage incomplete → engine rejects continue; dev stage forces TDD |
| Context explodes mid-change, requirements / design / code all lost | Everything lives under .taiyi/changes/<slug>/; token overflow auto-writes CONTEXT-COMPACT.md |
| Each of OpenCode / Claude / Codex / Cursor has its own ad-hoc flow | One set of taiyi-* Skills, sync to any of the four harnesses |
| Even a typo fix has to go through nine stages? | 7 profiles (full → nano), auto-routes by change complexity |
| Don't dare let AI decide at critical nodes | change / design / review are human gates + --approver, skipped only when --approver is set |
| Don't know what the installed Skills are actually doing | taiyi doctor / audit self-check + failures / high-findings triage |
| Want to coexist with OMC / OMX | Doesn't depend on oh-my-claudecode; Taiyi owns artifacts, OMX owns parallel execution |
The Nine-Stage Workflow
One change = one slug, sequential execution, fixed artifacts. Human gates require --approver before the engine lets you pass.
| # | Phase | Category | Skill | Artifact | Notes |
|---|---|---|---|---|---|
| 1 | change | Human gate | taiyi-change | CHANGE.md | 3-5 paragraph proposal with scope |
| 2 | requirement | Auto | taiyi-requirement | REQUIREMENT.md | Acceptance criteria + AC checkbox |
| 3 | design | Human gate | taiyi-design | DESIGN.md | ≥2 options compared + decision |
| 4 | ui-design | Auto | taiyi-ui-design | UI-DESIGN.md | Only for changes that touch UI |
| 5 | task | Auto | taiyi-task | TASK.md | Slice into independently-PR-able pieces |
| 6 | dev | Auto | taiyi-dev | TDD test + minimal impl | TDD forced — red first, then green |
| 7 | test | Auto | taiyi-test | TEST.md | Summary kept; E2E runs in CI |
| 8 | review | Human gate | taiyi-review | REVIEW.md | Cross-AI review + high-severity must-fix |
| 9 | integration | Auto | taiyi-integration | CHANGELOG.md merged | Delivery gate: audit + deliveryVerifyCmd |
| — | archive | Cleanup | taiyi-integration | .taiyi/archive/ | Only after all nine stages pass |
Full command list → canonical-commands.md · Artifact layout → artifact-layout.md
One Skill Set, Four Harnesses
One taiyi-forge-install --all syncs to all four harnesses; missing ones are auto-skipped:
| Harness | How to verify | Notes |
|---|---|---|
| OpenCode | opencode.json contains oh-my-taiyiforge; after restart you'll see taiyi_new / taiyi_* tools | Official plugin, deep integration |
| Claude Code | ls ~/.claude/skills/taiyi-change · ~/.claude/mcp.json | Slash / Skill / MCP |
| Codex | ls ~/.codex/skills/taiyi-change · ~/.codex/mcp.json | $taiyi-* keyword-driven |
| Cursor | ~/.cursor/skills/taiyi-change · taiyiforge.mdc · project .cursor/mcp.json | Rule + MCP dual channel |
Codex users trigger via $taiyi-new / $taiyi-forge etc. — see agents.yaml.
Quick Start
Status note: v0.23.0 is not yet published to npm. The only install path right now is from source. CI is green, npm will follow; badges will switch automatically.
Option A: Source install (recommended, ready now)
git clone https://github.com/Dong90/oh-my-taiyiforge.git
cd oh-my-taiyiforge
npm install && npm run build && npm test
Option B: Install into your project (also source)
git clone https://github.com/Dong90/oh-my-taiyiforge.git
cd oh-my-taiyiforge
npm install && npm run build
# Install to all four harnesses + optional triangles
# (OpenSpec / gstack / Superpowers / web-quality-skills)
node scripts/taiyi-forge.sh install --all
# Or one harness at a time:
node scripts/taiyi-forge.sh install --cursor
node scripts/taiyi-forge.sh install --claude --cursor
# Skip optional deps:
node scripts/taiyi-forge.sh install --all --skip-deps
Option C: Run the demo projects
cd examples/commands-smoke
npm install
npm run chat-demo # Chat verbs: new / status / check / continue
npm run walkthrough-e2e # Nine-stage shell E2E + iron-triangle
npm run taiyi:doctor # Workspace + install self-check
Want
npm install oh-my-taiyiforge? Wait for the Releases announcement — it'll light up here first.
Your First Change (5 minutes)
mkdir demo && cd demo
npm init -y
git clone https://github.com/Dong90/oh-my-taiyiforge.git .taiyi-forge # temporary engine
# (after npm publish, this becomes: npm install oh-my-taiyiforge)
# Recommended entry: auto-slug + engine guidance
npx taiyi walkthrough
npx taiyi new "Add login optimization" # writes to .taiyi/changes/<slug>/
npx taiyi status # current phase + recommended Skill + next step
# Edit .taiyi/changes/<slug>/CHANGE.md, then:
npx taiyi complete <slug> change --approver "your-name" # human gate
npx taiyi continue <slug> # auto gate
# In chat (OpenCode / Claude / Cursor):
/taiyi:new "feature description"
/taiyi:status
/taiyi:write # write current stage artifact
/taiyi:continue --approver "your-name"
/taiyi:commit # post-dev commit with Taiyi-Change trailer
/taiyi:archive # archive after all nine stages
That's it. Phase order, artifact templates, gate validation are the engine's job. You write Markdown and code.
Chat Track vs Engine Track
TaiyiForge deliberately splits responsibilities — similar to oh-my-claudecode's "session Skills + CLI control plane" idea, but the spine is the nine-stage artifact contract:
| Surface | Used by | Does what | Example |
|---|---|---|---|
| Chat slash | Developer / Agent | Write artifact, run TDD, load specialized Skill | /taiyi:write · /taiyi:apply · /taiyi:tdd dev |
| Engine CLI | Agent / CI (run for you) | Validate artifact, gates, advance phase | npx taiyi continue <slug> · npx taiyi complete <slug> change --approver "…" |
| Shell entry | Agent / CI | Equivalent to CLI; written into consumer project after install | scripts/taiyi-forge.sh status --json --compact |
| MCP | Cursor etc. | Read-only troubleshooting | taiyi_doctor · taiyi_audit |
Principle: Users only say /taiyi:*; never make the user type taiyi-forge.sh by hand. Agents read status --json --compact engineTruth; never dump full artifacts into chat.
Agent-priority troubleshooting:
scripts/taiyi-forge.sh doctor --json --compact
scripts/taiyi-forge.sh audit --json --compact
Core Capabilities
- Nine-stage artifact contract — requirement → design → dev → test → review → archive, all auditable under
.taiyi/changes/<slug>/ - Agent cannot skip stages — previous stage incomplete ⇒ engine rejects
continue; dev forces TDD; integration runs the delivery gate - One Skill set, four harnesses — 23
taiyi-*synced to OpenCode / Claude / Codex / Cursor viataiyi-forge-install - Right-sized routing — 7 profiles (full → nano); big features go nine-stage, typo fixes go nano
- Compose, don't lock-in — Harness · OpenSpec · GStack · Superpowers · OMO · Spec-Kit integrations; not installed = auto-skipped as optional
- Long sessions survive — token budget +
/taiyi:token compress→CONTEXT-COMPACT.md+ handoff - Coexists with OMC / OMX — doesn't depend on oh-my-claudecode; pairs with oh-my-codex for multi-agent orchestration (Taiyi = artifacts, OMX = parallel execution)
- TDD forced — dev stage: failing test first, minimal impl second;
npm testmust pass before advancing to test stage - Platform smoke — CI matrix runs OpenCode / Claude / Codex / Cursor, prevents single-platform drift
Architecture at a Glance
┌─────────────────────────────────────────────────────────────┐
│ Entry: taiyi CLI · taiyi-forge.sh · OpenCode plugin · MCP │
└───────────────────────────┬─────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ workflow-engine — intent analysis · token budget · routing · gates │
└───────────────────────────┬─────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ .taiyi/changes/<slug>/ — CHANGE … CHANGELOG (source of truth) │
└─────────────────────────────────────────────────────────────┘
chat loads taiyi-* Skill to write artifacts ↑ ↓ engine validates & advances phase
- Code layout → docs/ARCHITECTURE.md
- C4 source → docs/c4/
- Visual poster (top of README) → docs/diagrams/visual/
Documentation
| Document | What it covers | When to read |
|---|---|---|
| docs/QUICKSTART.md | 5-minute walkthrough | First install |
| docs/USAGE.md | Scenarios · daily rhythm · delivery chain | After the walkthrough |
| docs/ARCHITECTURE.md | Architecture overview + code layout | Hacking the engine / debugging |
| docs/taiyi/canonical-commands.md | v28 slash command table | Looking up a command |
| docs/taiyi/control-plane.md | Agent discipline + token discipline | Onboarding an Agent |
| docs/taiyi/full-oss-flow.md | Superpowers + all-plugins demo | Want a full end-to-end |
| docs/taiyi/integrations.md | Iron triangle + plugin integrations | Installing optional pieces |
| AGENTS.md | Agent's read-state entry point | Configuring Agents |
| CONTRIBUTING.md | Contribution guide | Before opening a PR |
| CHANGELOG.md | Release notes | Checking for updates |
| docs/diagrams/demo.gif | Real terminal recording (27s) | Quick feel of the engine |
| README.zh-CN.md | 简体中文版 | 中文用户 |
Development & Verification
Contributor clone:
git clone https://github.com/Dong90/oh-my-taiyiforge.git
cd oh-my-taiyiforge
npm install && npm run build && npm test
npx taiyi-forge-install --all
Common commands:
npm test # Vitest contracts + nine-stage E2E
npm run test:watch # watch mode
npm run build # TypeScript → dist/
npm run dogfood # root repo demo (eat your own dog food)
npm run ci:platforms # four-platform smoke (opencode/claude/codex/cursor)
npm run check:docs # doc-vs-commands.yaml sync check
Example projects:
| Directory | Purpose |
|---|---|
| examples/full-flow-demo | Nine-stage + slash E2E |
| examples/commands-smoke | Command smoke tests |
| examples/browser-e2e-smoke | CI templates |
| examples/verification-suite | Minimal integration demo |
CI: .github/workflows/ci.yml — platform smoke runs across a 4 × ubuntu matrix.
Roadmap & Status
| Version | Status | Key milestones |
|---|---|---|
| v0.23.0 | ✅ Released | canonical v28 convergence · catalog-validation gate · skill-fusion principles documented |
| v0.24.x | 🚧 In progress | First npm release · oh-my-taiyiforge zero-build install for consumer projects |
| v1.0.0 | ⏳ Planned | Lock 9-stage API · 4-platform parity · external case-study collection |
Ready today: full nine-stage pipeline · four-harness shared Skills · forced TDD · token compression · platform-smoke CI Not yet: one-line npm install (v0.24 target) · production-grade SLA · full i18n
Community & Contributing
- 🐛 Report a bug: GitHub Issues ·
buglabel - 💡 Idea / RFC: Discussions
- 🔧 Open a PR: read CONTRIBUTING.md first;
npm test+npm run check:docsmust be green - ⭐ Star / Watch: drop a star to get notified on the next release
- 🧵 Codex users: search for
$taiyi-*keywords; four-harness entry decision tree in docs/taiyi/invoke.yaml
Code of conduct: follow the Contributor Covenant spirit — critique ideas, not people.
License
MIT © 2026 TaiyiForge contributors
Acknowledgments
Inspired by: oh-my-claudecode · oh-my-codex · Harness Engineering · OpenSpec · GStack · Superpowers · OMO · Spec-Kit.