CTO Skill

AI-native CTO skills for Codex: repository-backed planning, evidence-driven review, risk-tiered autonomy, and governed multi-agent delivery.

简体中文 · Install · How it works · Examples · Governance

Why this exists

Coding agents make implementation faster, but code generation is rarely the only delivery bottleneck. Product intent, design decisions, review capacity, verification, release gates, and operational learning must keep up too.

CTO Skill turns that broader lifecycle into an executable operating model. It helps Codex act as a technical owner across planning and review while keeping durable artifacts, deterministic controls, human accountability, and production safety explicit.

What you get

• cto — routes top-level ownership requests to the smallest correct workflow.
• cto-planner — creates repository-backed roadmaps, phase plans, artifact contracts, ownership splits, autonomy tiers, gates, and measurable exit criteria.
• cto-reviewer — verifies branch and PR claims against current mainline, committed plans, validation evidence, controls, provenance, and release requirements.
• AI-native governance reference — shared lifecycle rules covering artifacts, human gates, autonomy, controls, evals, provenance, metrics, and incident learning.
• Repository-state collector — a read-only script that reports exact SHAs, ahead/behind state, worktrees, remote tracking, dirty state, and commit identity.

How it works

flowchart LR
    U["CTO request"] --> R["cto router"]
    R -->|"new or revised direction"| P["cto-planner"]
    R -->|"verify current work"| V["cto-reviewer"]
    V -->|"evidence changes priorities"| P
    P --> A["Committed plan and assignments"]
    V --> M["Verdict, governed merge, and next round"]

Loading

The bundle preserves an AI-native artifact chain:

intent → specification → implementation plan → code and verification
       → PR and review → release evidence → incident and learning

Chats and agent reports are treated as claims. Repository state, committed artifacts, exact SHAs, raw validation signals, approvals, and run/build evidence are treated as proof.

Core behavior

Planning

cto-planner starts from the latest repository and mainline state, then defines:

• product outcome, current phase, constraints, and bottleneck;
• durable artifacts and sources of truth;
• phase entry/exit criteria;
• risk and autonomy tiers;
• human decision owners;
• deterministic validation, independent review, observability, and rollback;
• coherent multi-agent ownership bounded by review capacity;
• delivery, stability, cost, review-load, and agent-quality metrics.

Review and merge

cto-reviewer verifies the exact branch or PR instead of trusting a status report. It uses one verdict:

• ready_to_merge
• valuable_but_fix_first
• do_not_merge_yet
• redo_on_latest_mainline

When work is verified as ready_to_merge, the reviewer merges by default unless the user explicitly asks for review-only behavior or forbids integration. The standing authority is limited to the exact reviewed commits and their GitHub-visible integration path.

Merge authority is not production release authority. Production still requires the named human gate and platform enforcement.

Governance model

Layer	Purpose	Examples
Advisory	Make correct behavior likely	AGENTS.md, CLAUDE.md, skills, prompts, review policy
Deterministic	Make mandatory rules enforceable	tests, schema checks, CI, hooks, branch protection, IAM, release gates

Autonomy	Agent capability	Default gate
A0	Read and diagnose	Human chooses action
A1	Draft plans and recommendations	Human accepts the artifact
A2	Edit a sandboxed branch and open a PR	Code-owner approval or standing CTO integration authority
A3	Run an allowlisted, reversible runbook	Named approval or narrow pre-authorization
A4	Unattended lifecycle loop	Exceptional; explicit risk acceptance required

Autonomy is based on observability, reversibility, permission scope, verification strength, and blast radius—not on model confidence alone.

Installation

Codex

Clone the repository and copy all three sibling skills into your Codex skills directory:

git clone https://github.com/Bliveren/CTO-skill.git
mkdir -p ~/.codex/skills
cp -R CTO-skill/skills/cto ~/.codex/skills/
cp -R CTO-skill/skills/cto-planner ~/.codex/skills/
cp -R CTO-skill/skills/cto-reviewer ~/.codex/skills/

Start a new Codex task after installation so the skill metadata is discovered.

Other Skills-compatible installations

Copy the same three directories into the product's configured skills root. Keep them as siblings because the planner and reviewer share cto/references/ai-native-governance.md.

Usage examples

Route a mixed CTO request:

Use $cto to review the current agent branches, merge everything that is truly ready,
then revise the next phase plan from the verified mainline state.

Create an AI-native rollout:

Use $cto-planner to create an eight-week AI-native SDLC rollout for these services.
Include artifact contracts, risk tiers, human gates, evals, rollback, and exit criteria.

Audit an agent update:

Use $cto-reviewer to verify this branch against origin/main and the active plan.
Check test integrity, plan drift, provenance, rollback, and release readiness.
Merge it if and only if it is ready.

Request review without merge:

Use $cto-reviewer in review-only mode. Do not merge or push anything.

Repository-state collector

Run the included read-only evidence helper:

skills/cto-reviewer/scripts/collect_repo_state.sh /path/to/repository origin/main

It reports:

• repository root and mainline reference;
• branch, HEAD, mainline, and merge-base SHAs;
• ahead/behind and dirty state;
• upstream and remote branch SHAs;
• Git commit name/email;
• active worktrees.

The script never fetches, modifies, commits, pushes, or merges.

Package layout

skills/
├── cto/
│   ├── SKILL.md
│   ├── agents/openai.yaml
│   └── references/ai-native-governance.md
├── cto-planner/
│   ├── SKILL.md
│   └── agents/openai.yaml
└── cto-reviewer/
    ├── SKILL.md
    ├── agents/openai.yaml
    └── scripts/collect_repo_state.sh

Design principles

• Tool-neutral governance with thin product-specific adapters.
• Durable repository artifacts instead of chat-only plans.
• Independent evidence instead of self-reported success.
• Small, coherent delivery slices instead of micro-task churn.
• Human accountability at intent, risk, merge, release, and incident gates.
• Deterministic controls behind mandatory policy.
• Incidents and repeated findings become tests, evals, or controls.
• Git history contributes to provenance but is not the whole audit trail.

Inspiration and standards

The operating model is informed by:

• The AI-Native SDLC Playbook
• DORA software delivery research
• NIST Secure Software Development Framework
• NIST AI Risk Management Framework
• SLSA specification
• OWASP Top 10 for Agentic Applications

This project is an independent open-source implementation and is not affiliated with or endorsed by Anthropic, OpenAI, Google, NIST, SLSA, or OWASP.

Contributing

Issues and pull requests are welcome. See CONTRIBUTING.md. For security-sensitive reports, follow SECURITY.md.

If CTO Skill helps your team ship agent-assisted software with better evidence and control, please star the repository. Stars help other engineering leaders discover it.

License

MIT © 2026 Bliveren.