@juniyadi/pi-cto

CTO mode for pi — 20 years of engineering leadership codified into a reusable prompt.

What It Does

Activates CTO thinking with 15 skills, workflow presets, 5 gates, and cross-session persistence.

Core Skills

| Skill | Use When | |-------|----------| | Basic CTO | Decisions, recommendations, trade-off analysis | | Reviewer | Bug reports, incidents, code changes | | Inspector | Code audits, architecture reviews, health checks | | Planner | Execution plans, migrations, strategies | | Task Splitter | Breaking work into actionable tasks | | Delegation | Assigning work to teams/agents | | Implementation | Applying scoped changes with verification evidence | | Cleanup | Refactors, dead-code removal, behavior-preserving debt reduction | | Final Review | Verifying delivery before ship | | Design Lead | UI/UX reviews, frontend architecture, accessibility |

Document Generation Skills

| Skill | Use When | |-------|----------| | PRD | Product Requirements Documents | | Design Spec | System architecture & API design docs | | RFC | Technical proposals & ADRs | | Tech Spec | Implementation specifications | | Post-Mortem | Incident RCA & learning docs |

Gates (Always Active)

1. USER-FIRST — What does the user actually need?
2. KISS — Simplest solution that works?
3. DRY — Duplicating something shared?
4. YAGNI — Building something not needed yet?
5. Bike vs Lambo — Complexity proportional to need?

Install

pi install npm:@juniyadi/pi-cto

That's it. /cto, /cto-init, /cto-status, /cto-continue, and /skill:cto are now available globally.

Usage

/cto                                  → Auto-detect mode or workflow preset
/cto reviewer analyze this bug        → Issue analysis
/cto inspector audit the auth module  → Code audit
/cto planner plan the migration       → Execution strategy
/cto task-splitter break this feature → Work decomposition
/cto delegation assign these tasks    → Task assignment
/cto implementation build the fix     → Scoped implementation + evidence
/cto cleanup remove dead code         → Behavior-preserving cleanup
/cto final-review verify the impl     → Delivery verification
/cto design-lead review the UI        → UI/UX + accessibility review

# Workflow Presets
/cto prd-first new user auth          → PRD → design → tech spec → plan → tasks → implementation → review
/cto fast-fix login bug               → Review → implementation → final review
/cto architecture payment flow        → Design spec → RFC → plan
/cto audit auth module                → Inspector → reviewer → planner
/cto planning-only migration          → Basic CTO → planner → task splitter
/cto continue billing-migration       → Continue one lazy-loaded context
/cto cleanup-flow old billing code    → Inspector → cleanup → final review

# Continuation Context
/cto-status                           → List indexed continuation contexts
/cto-status billing-migration         → Show index status for one slug
/cto-continue billing-migration       → Check/scaffold context, then resume one guide
/cto-continue                         → List contexts and suggest next step

# Document Generation
/cto prd create user auth feature     → Product Requirements Document
/cto design-spec for payment flow     → System architecture doc
/cto rfc propose new caching layer    → Technical RFC
/cto tech-spec implement login page   → Implementation spec
/cto post-mortem for outage on June 5 → Incident RCA

Workflow Presets

Presets are routing shortcuts; explicit mode commands still work. Use a preset when the user asks for an end-to-end CTO workflow instead of one skill.

| Preset | Typical sequence | |--------|------------------| | prd-first | PRD → Design Spec → Tech Spec → Planner → Task Splitter → Delegation → Implementation → Final Review | | fast-fix | Reviewer → Implementation → Final Review | | architecture | Design Spec → RFC → Planner | | audit | Inspector → Reviewer → Planner | | planning-only | Basic CTO → Planner → Task Splitter | | continue | /cto-continue lifecycle gate | | cleanup-flow | Inspector → Cleanup → Final Review |

Before moving between stages, CTO validates the relevant artifact for that stage (PRD/spec/task/context/review/evidence) instead of loading every project file.

Cross-Session Persistence

CTO work spans sessions. Initialize project artifacts:

/cto-init

This creates .cto/ in your project:

.cto/
├── decisions/        ← architectural decisions
├── reviews/          ← review reports
├── tasks/            ← actionable work units
├── context/          ← lazy-loaded continuation context
│   ├── index.md      ← compact status index
│   └── {slug}.md     ← one feature/context guide
├── architecture/     ← system design docs
├── tech-debt/        ← tracked debt
├── prd/              ← product requirements documents
├── design-specs/     ← architecture & API design docs
├── rfcs/             ← technical proposals
├── tech-specs/       ← implementation specifications
└── post-mortems/     ← incident RCAs

CTO uses these artifacts to maintain consistency across sessions. Continuation context is lazy-loaded: /cto-status [slug] reads only .cto/context/index.md, while /cto-continue [slug] is the lifecycle gate: with a slug it checks/scaffolds missing context and reads only the requested guide; without a slug it lists contexts and guides the user.

Lifecycle phases are lightweight: discover → specify → plan → implement → verify → cleanup → continue/archive. Context statuses remain active, blocked, paused, done, or archived.

Lazy-Load Architecture

Skills are loaded on demand — only the relevant skill file is read into context:

| When You Say | What Loads | Tokens | |--------------|------------|--------| | /cto reviewer | core.md + reviewer.md | ~900 | | /cto implementation | core.md + implementation.md | ~900 | | /cto cleanup | core.md + cleanup.md | ~900 | | /cto prd | core.md + prd.md | ~1,000 | | /cto design-spec | core.md + design-spec.md | ~1,100 | | /cto-status | .cto/context/index.md only | project-sized | | /cto-continue [slug] | core.md + context index + one slug guide; templates only if scaffolding | project-sized |

Not loaded: Other skill files or unrelated .cto/context/*.md guides (saves tokens per request)

File Structure

@juniyadi/pi-cto/
├── skills/
│   └── cto/
│       ├── SKILL.md                    ← router (detects mode/preset, loads skill)
│       ├── core.md                     ← gates & enforcement (always loaded)
│       ├── skills/                     ← individual skill protocols
│       │   ├── basic-cto.md
│       │   ├── reviewer.md
│       │   ├── inspector.md
│       │   ├── planner.md
│       │   ├── task-splitter.md
│       │   ├── delegation.md
│       │   ├── implementation.md
│       │   ├── cleanup.md
│       │   ├── final-review.md
│       │   ├── design-lead.md
│       │   ├── prd.md
│       │   ├── design-spec.md
│       │   ├── rfc.md
│       │   ├── tech-spec.md
│       │   └── post-mortem.md
│       └── templates/                  ← document templates
│           ├── README.md
│           ├── decision.md
│           ├── review.md
│           ├── task.md
│           ├── context-index.md
│           ├── context-guide.md
│           ├── tech-debt.md
│           ├── architecture.md
│           ├── prd.md
│           ├── design-spec.md
│           ├── rfc.md
│           ├── tech-spec.md
│           └── post-mortem.md
└── prompts/
    ├── cto.md                          ← /cto command
    ├── cto-init.md                     ← /cto-init command
    ├── cto-status.md                   ← /cto-status command
    └── cto-continue.md                 ← /cto-continue command

Validator Scripts

For release smoke checks or local package validation, use the bundled npm scripts:

npm run cto:detect -- "cleanup-flow old billing code"
npm run cto:mode -- cleanup
npm run cto:workflow -- cleanup-flow
npm run cto:pipeline -- <slug>
npm run cto:validate -- <slug>

Additional continuation helpers are available as cto:pre, cto:post, cto:status, and cto:schema; mode helpers include cto:mode-list.

Updating

pi update npm:@juniyadi/pi-cto

License

MIT