Dev Codex — AI Coding Skill Library

One rule set. Every project. Zero repeated context.

---

What this is

Each .md file is a skill — instructions that shape how your AI coding assistant thinks for a specific job. Instead of typing long prompts every session, you invoke a skill and the assistant operates under the right constraints immediately.

Skills stack. When PROJECT_CONTEXT.mdc is always-on AND you invoke /raiden-shogun, both constraint layers are active simultaneously — without repeating either.

The result: less prompt writing, fewer wasted tokens, more consistent output across sessions.

---

Platform setup

Claude Code

Place skill files anywhere in your project. Reference them:

use the skill at SKILLS/architect.md

Or place them in .claude/commands/ and they become /slash commands.

You can also create a CLAUDE.md at project root to load rules on every session (equivalent to Cursor's alwaysApply).

Cursor

Place .md or .mdc files inside .cursor/rules/ at your project root.

Mode	How	When
Manual	/command-name	Skills you choose situationally
Always-on	alwaysApply: true in frontmatter	PROJECT_CONTEXT.mdc — loads every chat
Auto-attach	globs: src/**/*.tsx in frontmatter	Loads when matching files open

Windsurf

Place .md files in .windsurfrules/ at your project root. Similar activation to Cursor.

Copilot

Add instructions to .github/copilot-instructions.md. Combine relevant skill content into this file.

Other tools (Aider, Cline, Continue)

Most tools support a project-level instruction file. Copy the relevant skill content into whichever file your tool reads.

---

File structure

your-project/
│
├── .cursor/rules/                      ← Cursor reads automatically
│   ├── PROJECT_CONTEXT.mdc             ← alwaysApply: true — per project
│   └── auto-[type].mdc                 ← globs-based auto-attach rules
│
├── memory/                             ← shorekeeper writes here
│   ├── INDEX.md
│   └── memory_YYYY-MM-DD.md
│
└── SKILLS/                             ← your skill library
    ├── core/                           ← always available, project-independent
    │   ├── raiden-shogun.md
    │   ├── shorekeeper.md
    │   ├── trigger.md
    │   └── resume.md
    │
    ├── from-scratch/                   ← building a new project
    │   ├── architect.md
    │   ├── aibuilder.md
    │   ├── fullstack.md
    │   ├── integrator.md
    │   ├── uxlaw.md
    │   ├── reviewer.md
    │   └── shipchecklist.md
    │
    ├── from-middle/                    ← returning to a partial build
    │   ├── PROJECT_CONTEXT.mdc         ← template — copy per project
    │   ├── AUTO_ATTACH_RULES.mdc       ← template — copy per file type
    │   └── EXAMPLE_veripay_context.mdc ← filled example to learn from
    │
    ├── fix/                            ← something is broken
    │   ├── bugcourt.md
    │   └── nightwatch.md
    │
    └── team/                           ← team builds and hackathons
        ├── hackathon.md                ← full hackathon orchestrator
        ├── blitz.md
        ├── warroom.md
        └── pitchready.md

Open the folder that matches your situation. Starting fresh → from-scratch/. Returning → from-middle/. Broken → fix/. Team → team/.

---

Workflows

🔵 Starting a new project

/shorekeeper check     →  Read memory if it exists
/architect             →  Design before code
/raiden-shogun         →  Activate coding discipline (stays on)
  ├── /aibuilder       →  When building AI/ML components
  ├── /fullstack       →  When wiring frontend + API + DB
  └── /integrator      →  When orchestrating multiple APIs
/uxlaw                 →  UI polish — after it works
/reviewer              →  Code review before PR
/shipchecklist         →  Final 30 minutes before deploy
/shorekeeper           →  Save session memory

🟡 Returning to a partial build

/shorekeeper check     →  Read last session
Fill PROJECT_CONTEXT   →  If not already done
/resume                →  Claude reads codebase, maps what exists
  Confirm map          →  Correct anything wrong
  Continue from /raiden-shogun onward

🔴 Hackathon (time-boxed team build)

/hackathon             →  Full orchestrator (covers all 5 phases below)
  │
  ├── Phase 1: WAR ROOM        →  Team split + contracts (30 min)
  ├── Phase 2: BUILD            →  Blitz rules active
  │     └── /raiden-shogun      →  Coding discipline alongside
  ├── Phase 3: NIGHTWATCH       →  If something breaks late
  ├── Phase 4: PITCH READY      →  Stop building, start winning
  └── Phase 5: SHIP CHECK       →  Final verification

You can also invoke phases individually:

• /warroom — just the team split
• /blitz — just the build mode
• /nightwatch — just the triage
• /pitchready — just the demo prep

⚫ Something is broken

/bugcourt              →  Systematic triage. Hypothesis before change.
/nightwatch            →  Deadline close? FIX / MOCK / CUT.
/nightwatch spiral     →  Stuck 45+ min? Force mock or cut.

---

All skills — quick reference

Core

Command	Job
/raiden-shogun	Coding discipline. Touch only what you must. Restraint as law.
/shorekeeper check	Read session memory. Orient at start of every session.
/shorekeeper	Write session memory. Run at end of every session.
/trigger	Token survival mode. Minimum tokens. No filler.
/resume	Read an existing codebase before touching it.

From Scratch

Command	Job
/architect	Design data model + service boundaries before code.
/aibuilder	AI/ML pipelines. Baseline first. Evals before deploy.
/fullstack	Frontend + API + DB. Data flows down, events flow up.
/integrator	Multi-API orchestration. Retry logic. Fan-out.
/uxlaw	UI polish. Three states. Hierarchy. Error messages.
/reviewer	Code review. BLOCK or SUGGEST. No style nitpicks.
/shipchecklist	Pre-deploy checklist. Hackathon or production mode.

Team / Hackathon

Command	Job
/hackathon	Full hackathon orchestrator. 5 phases, team setup to ship.
/blitz	Time-boxed build mode. Demo over everything.
/warroom	Team split + integration contracts + sync checkpoints.
/pitchready	Demo script. Q&A prep. Hide broken parts.

Fix

Command	Job
/bugcourt	Systematic triage. Reproduce → isolate → hypothesize → test.
/nightwatch	Deadline triage. FIX / MOCK / CUT. No rabbit holes.

---

How skills reduce tokens

Without skills: Every session you re-paste context, re-explain the project, re-state constraints. The first 500 tokens are wasted on orientation.

With skills:

• PROJECT_CONTEXT.mdc loads project state automatically — stack, decisions, what's broken — without typing.
• Auto-attach rules load file-specific constraints when you open a file.
• /trigger cuts response length by 60–70%.
• /shorekeeper saves session state so the next session starts warm.
• Skills themselves are compact — dense instructions, not explanations.

Stacking: PROJECT_CONTEXT.mdc (always-on) + /raiden-shogun (manual) + auto-react.mdc (auto-attach) = three constraint layers from one command.

---

Setting up a new project

# 1. Copy templates into your project
cp -r SKILLS/from-middle/ your-project/.cursor/rules/

# 2. Fill in PROJECT_CONTEXT.mdc — replace every [placeholder]
#    Set alwaysApply: true in frontmatter

# 3. Copy auto-attach rules you need, fill in placeholders

# 4. First message: /shorekeeper check
#    Memory exists → read it. No memory → start fresh.

# 5. Returning to existing code? /resume
#    Claude reads the codebase. You confirm. Then build.

---

Skill scoping — why they do not conflict

Each skill governs one domain:

Skill	Governs
raiden-shogun	How code is written (restraint)
architect	Decisions before coding (data model, boundaries)
aibuilder	AI component construction (pipelines, evals)
fullstack	Layer separation (data flow direction)
integrator	External service orchestration (retry, fan-out)
uxlaw	UI quality (states, hierarchy)
reviewer	Pre-ship checks (security, correctness)
hackathon	Time-boxed team build (phases, task split)
PROJECT_CONTEXT	Project-specific overrides

When a PROJECT_CONTEXT.mdc override conflicts with a base skill, project context wins.

---

Built for everyone. Stack: any.