code-abyss

Composable persona · style · 30 engineering skills · 4 native security domains · self-evolution forge · code graph intelligence
for Claude Code · Codex CLI · Gemini CLI · OpenClaw

Website · Spec · 中文文档 · Changelog · Submit Persona

The problem

Most AI coding agents have no memory of who they are. They respond in the same flat tone whether they're debugging a race condition, reviewing architecture, or triaging a P0 incident. They forget your conventions between sessions. They flip-flop on advice. They sound like a help-desk script.

And when you ask them about security — pentest, code audit, threat modeling, IR — most agents fall back to generic OWASP recitation, because the underlying skill library was never written by people who actually run red/blue/purple teams.

You don't want a help desk. You want a principal engineer who shows up with a personality, executes consistently, closes the loop — and has a security spine when things get real.

What Code Abyss does

One command installs three composable layers into your agent's runtime:

┌─────────────────────────────────────────────────────┐
│  Identity     who it is     →  config/personas/*.md │
│  Behavior     how it acts   →  _shared/*.md         │
│  Style        how it sounds →  output-styles/*.md   │
└─────────────────────────────────────────────────────┘

  6 personas  ×  6 styles  =  36 validated combinations

Pick any persona. Pair it with any style. The behavior layer (iron laws, execution chains, proactive protocol, skill routing) stays constant. Your agent becomes a consistent character with structured execution and domain expertise across every session.

What's new in v4

• 4 native security domains — 4073 lines of original defense engineering (no Apache-2.0 upstream)
• 30 skills total, all SKILL.md ≤ 110 lines (avg 59), heavy content lives in references/
• 5 verify skills rewritten as judgment-type knowledge (when to use, how to interpret output, exemption rules)
• Office skills slim to under 100 lines each; 4 design systems consolidated into one selector skill
• v4.1 — self-evolution forge: cultivating-skills / cultivating-personas let the agent distill repeated workflows into reusable skills, with a safety scan and a three-tier publish funnel (local → project → community)
• v4.4 — hardware + academic writing: 3 new domain skills (KiCad EDA, hardware product pipeline, AIGC detection reduction) + prompt injection defense + execution-drive shared behavior
• v4.5 — dynamic persona loading: only abyss ships with npm — all other personas are fetched from GitHub on first use and cached locally, slimming the package
• v4.6 — code graph intelligence: abyss CLI builds a code relationship graph (call graph + temporal analysis) in 5 seconds — caller tracing, impact analysis, hotspot detection, change coupling. Pre-edit hooks auto-check callers across all 4 platforms

npx code-abyss -t claude -y

Or as a Claude Code plugin:

claude plugin install code-abyss

Personas

Core persona (abyss) ships with npm and works offline. Remote personas are fetched from GitHub on first --persona <slug> use and cached at ~/.code-abyss/personas/.

# Mix freely — any persona × any style
npx code-abyss -t claude --persona elder-sister --style abyss-cultivator -y
# → fetches elder-sister on first run, cached thereafter

Browse the full gallery →

Security suite (v4 highlight)

4 native security skills, 4073 lines of original engineering content. No Apache-2.0 upstream — every example, every detection signal, every defense pattern is written for this project.

Plus securing-systems as the router skill covering pentest, code audit, red/blue/purple team operations. Every attack technique ships with the matching detection signal and mitigation pattern — "with offense as defense" is structural, not lip service.

Code graph intelligence (v4.6 highlight)

Your agent can now see code relationships. The abyss CLI builds a full call graph, temporal analysis, and hotspot map — in 5 seconds, with zero cloud dependencies.

The indexing-code skill automatically hooks into all 4 supported platforms — before every Edit/Write, the agent checks callers and warns about high-impact changes. No MCP server needed; abyss runs as a CLI via the agent's shell tool.

# Real output from a 1862-file Go project (5 seconds to index):

$ abyss impact SetError
impact: SetError  direct=17  transitive=521  tests=469  uncovered=319  risk=10.0/10
  ⚠ high blast radius (17 direct callers)
  ⚠ deep dependency chain (521 transitive)
  ⚠ 319 call paths without test coverage

abyss is a separate Rust binary (code-abyss-dev). Install: bash install.sh in the repo, or copy the release binary to ~/.local/bin/abyss.

Skills

30 domain skills, flat structure, agentskills.io aligned (with Code Abyss extensions). Skills load by context — the agent reads the right knowledge at the right time without being asked. Average SKILL.md is 59 lines; heavy content lives in references/.

Five skills also ship as executable verification tools for CI:

node skills/analyzing-security/scripts/security_scanner.js .       # OWASP / injection / secrets
node skills/checking-code-quality/scripts/quality_checker.js .     # Complexity, dupes, naming
node skills/analyzing-changes/scripts/change_analyzer.js --mode staged
node skills/verifying-modules/scripts/module_scanner.js <path>
node skills/generating-docs/scripts/doc_generator.js <path>

Install

Target	Command	Artifacts
	npx code-abyss -t claude -y	CLAUDE.md + skills + output styles + settings
	npx code-abyss -t codex -y	instruction.md + skills + config.toml
	npx code-abyss -t gemini -y	GEMINI.md + skills + commands
	npx code-abyss -t openclaw -y	Skills + workspace AGENTS.md / SOUL.md

npx code-abyss                      # Interactive — pick target, persona, style
npx code-abyss --list-styles        # Browse styles
npx code-abyss --uninstall claude   # Clean removal, restores user backups

Code Abyss tracks every installed file in .code-abyss-backup/manifest.json. Uninstall restores your previous configuration verbatim. Your custom skills coexist with Code Abyss skills — install/uninstall preserves anything you put under ~/.{target}/skills/ yourself.

Upgrading

Tech Persona Card · open standard

Code Abyss introduces Tech Persona Card v1.0 — the first portable format for AI agent persona interchange. Think Character Card V2, but for engineering workflows instead of roleplay.

Each persona ships as a structured persona-card.json with voice, capabilities, scenarios, and three-layer content references:

{
  "spec": "tech-persona-card",
  "spec_version": "1.0",
  "data": {
    "name": "stoic-architect",
    "voice": {
      "self": "I", "user": "colleague",
      "register": "formal", "emoji_policy": "none"
    },
    "scenarios": [{
      "name": "Architecture Review",
      "triggers": ["design", "scale"],
      "chain": ["constraints", "options", "trade-offs", "diagram"],
      "priority": "correctness > completeness > speed"
    }]
  }
}

Bidirectional converters ship out of the box:

const { toCharaCardV2, toGPTInstructions, fromCharaCardV2 } =
  require('code-abyss/bin/lib/persona-converter');

const cc  = toCharaCardV2(card, { identityContent });   // → SillyTavern / Chub.ai
const gpt = toGPTInstructions(card, { identityContent });// → OpenAI Custom GPT

Specification · JSON Schema · Reference cards

Why Code Abyss

Contributing

git clone https://github.com/telagod/code-abyss && cd code-abyss
npm install
npm test                    # 383 tests
npm run verify:skills       # Validate 30 skill contracts

Add a skill — create skills/<gerund-name>/SKILL.md with SKILL frontmatter, optionally add scripts/ for executable tools. npm run verify:skills validates the contract.

Submit a persona — open an Issue via the submission portal. The site walks you through generating a persona-card.json + identity.md with your own AI, reviewing, and submitting via a pre-configured issue template.

_{MIT License · v4.6.0 · made with 紫宵脉 by @telagod}