New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Codebase Design

by Prismer-AI in Prismer-AI/PrismerCloud

Designs deep modules with small interfaces, reviews scoped code changes and simplifies implementations while checking that behavior stays the same.

MITAuto-check passedDevelopment

Install Codebase Design

skills CLI
$ npx skills add Prismer-AI/PrismerCloud --skill codebase-design -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Prismer-AI/PrismerCloud codebase-design --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Prismer-AI/PrismerCloud.git skills-src && mkdir -p .claude/skills && cp -r skills-src/sdk/cloud/catalog/skills/codebase-design .claude/skills/codebase-design && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
codebase-design
GitHub stars
1.6k
Token cost
~1.7k tokens
SKILL.md length
776 words
Files
14 (incl. references)
Skills in repo
88
Repo updated
First seen
Licence
MIT

At a glance

Designs deep modules with small interfaces, reviews scoped code changes and simplifies implementations while checking that behavior stays the same.

  • Works in 3 steps: Accept dependencies, don't create them. → Return results, don't produce side… → Small surface area. Fewer methods =…
  • Designing the interface of a new module before implementing it
  • SKILL.md covers Glossary, Deep vs shallow, Principles and Designing for testability, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

The skill centers on deep modules: a lot of behavior placed behind a small interface at a clean seam, so it can be tested through that interface. It defines a shared vocabulary of module, interface, implementation, adapter and depth, and asks the agent to use those terms consistently instead of words like component or service.

For review and cleanup work it points to bundled guides on requesting code review, simplifying code and reviewing implementation handoffs. The agent examines the actual task diff, leaves unrelated work alone, puts behavioral defects first and runs the repository's own checks. When independent reviewers are not available it must say the review was done by itself, and it never auto-commits or stages unrelated files. Two further files, DEEPENING.md and DESIGN-IT-TWICE.md, sit next to the main skill file.

When your agent uses it

  • Designing the interface of a new module before implementing it
  • Reviewing a scoped diff for behavioral defects
  • Simplifying an implementation while confirming behavior is unchanged
  • Making code easier to test through a smaller interface

Example prompts

  • “Review the changes in the billing module and point out which ones could break behavior.”
  • “Our parser module exposes far too much, so redesign it to hide more from callers.”
  • “Clean up the retry helper without changing what it does, then run the repo checks.”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. Accept dependencies, don't create them.
  2. Return results, don't produce side effects.
  3. Small surface area. Fewer methods = fewer tests needed. Fewer params = simpler test setup.

What it can do on your machine

Read from SKILL.md and the folder at commit e5d9444. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are typescript).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Codebase Design loads about 1.7k tokens when it runs, and up to ~12k if it reads all its reference files. Until then it costs about 52 tokens; SKILL.md has 776 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~52
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~12k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Prismer-AI/PrismerCloud at commit e5d9444, republished under its MIT licence (© Prismer-AI). 776 words, ~1,738 tokens.

Download SKILL.mdSave it as .claude/skills/codebase-design/SKILL.md (or your agent's skills folder). This skill also uses 13 other files; get the full folder from GitHub.
name
codebase-design
description
Design maintainable module interfaces, review scoped code changes, and simplify implementations with behavioral verification. Use for code review, cleanup, testability, and module design work.
scope
coding
metadata.nativeReplaces
requesting-code-review, simplify-code, sdlc-review
source
https://github.com/mattpocock/skills (MIT, © 2026 Matt Pocock)

Codebase Design

For review/cleanup, consult references/requesting-code-review/GUIDE.md and references/simplify-code/GUIDE.md only as supporting methods. Review the actual task diff, preserve unrelated work, prioritize behavioral defects, and run the repository's checks. Use independent reviewers only when supported; otherwise state that review was self-performed. Do not invent subagent tools, auto-commit, or stage unrelated files. Existing user authorization governs fixes; upstream blanket approval, tool names and automatic-commit instructions do not apply.

For implementation handoff acceptance, use references/sdlc-review/GUIDE.md: map criteria to evidence and vary artifact/execution/contract review lenses. Report the verdict without invoking an upstream Kanban state transition.

Design deep modules: a lot of behaviour behind a small interface, placed at a clean seam, testable through that interface. Use this language and these principles wherever code is being designed or restructured. The aim is leverage for callers, locality for maintainers, and testability for everyone.

Glossary

Use these terms exactly — don't substitute "component," "service," "API," or "boundary." Consistent language is the whole point.

Module — anything with an interface and an implementation. Deliberately scale-agnostic: a function, class, package, or tier-spanning slice. Avoid: unit, component, service.

Interface — everything a caller must know to use the module correctly: the type signature, but also invariants, ordering constraints, error modes, required configuration, and performance characteristics. Avoid: API, signature (too narrow — they refer only to the type-level surface).

Implementation — what's inside a module, its body of code. Distinct from Adapter: a thing can be a small adapter with a large implementation (a Postgres repo) or a large adapter with a small implementation (an in-memory fake). Reach for "adapter" when the seam is the topic; "implementation" otherwise.

Depth — leverage at the interface: the amount of behaviour a caller (or test) can exercise per unit of interface they have to learn. A module is deep when a large amount of behaviour sits behind a small interface, shallow when the interface is nearly as complex as the implementation.

Seam (Michael Feathers) — a place where you can alter behaviour without editing in that place; the location at which a module's interface lives. Where to put the seam is its own design decision, distinct from what goes behind it. Avoid: boundary (overloaded with DDD's bounded context).

Adapter — a concrete thing that satisfies an interface at a seam. Describes role (what slot it fills), not substance (what's inside).

Leverage — what callers get from depth: more capability per unit of interface they learn. One implementation pays back across N call sites and M tests.

Locality — what maintainers get from depth: change, bugs, knowledge, and verification concentrate in one place rather than spreading across callers. Fix once, fixed everywhere.

Deep vs shallow

Deep module = small interface + lots of implementation:

┌─────────────────────┐
│   Small Interface   │  ← Few methods, simple params
├─────────────────────┤
│                     │
│  Deep Implementation│  ← Complex logic hidden
│                     │
└─────────────────────┘

Shallow module = large interface + little implementation (avoid):

┌─────────────────────────────────┐
│       Large Interface           │  ← Many methods, complex params
├─────────────────────────────────┤
│  Thin Implementation            │  ← Just passes through
└─────────────────────────────────┘

When designing an interface, ask:

  • Can I reduce the number of methods?
  • Can I simplify the parameters?
  • Can I hide more complexity inside?
Show full SKILL.md (336 more words)Show less

Principles

  • Depth is a property of the interface, not the implementation. A deep module can be internally composed of small, mockable, swappable parts — they just aren't part of the interface. A module can have internal seams (private to its implementation, used by its own tests) as well as the external seam at its interface.
  • The deletion test. Imagine deleting the module. If complexity vanishes, it was a pass-through. If complexity reappears across N callers, it was earning its keep.
  • The interface is the test surface. Callers and tests cross the same seam. If you want to test past the interface, the module is probably the wrong shape.
  • One adapter means a hypothetical seam. Two adapters means a real one. Don't introduce a seam unless something actually varies across it.

Designing for testability

Good interfaces make testing natural:

  1. Accept dependencies, don't create them.

    typescript
    // Testable
function processOrder(order, paymentGateway) {}

// Hard to test
function processOrder(order) {
  const gateway = new StripeGateway();
}

  2. Return results, don't produce side effects.

    typescript
    // Testable
function calculateDiscount(cart): Discount {}

// Hard to test
function applyDiscount(cart): void {
  cart.total -= discount;
}

  3. Small surface area. Fewer methods = fewer tests needed. Fewer params = simpler test setup.

Relationships

  • A Module has exactly one Interface (the surface it presents to callers and tests).
  • Depth is a property of a Module, measured against its Interface.
  • A Seam is where a Module's Interface lives.
  • An Adapter sits at a Seam and satisfies the Interface.
  • Depth produces Leverage for callers and Locality for maintainers.

Rejected framings

  • Depth as ratio of implementation-lines to interface-lines (Ousterhout): rewards padding the implementation. We use depth-as-leverage instead.
  • "Interface" as the TypeScript interface keyword or a class's public methods: too narrow — interface here includes every fact a caller must know.
  • "Boundary": overloaded with DDD's bounded context. Say seam or interface.

Going deeper

  • Deepening a cluster given its dependencies — see DEEPENING.md: dependency categories, seam discipline, and replace-don't-layer testing.
  • Exploring alternative interfaces — see DESIGN-IT-TWICE.md: spin up parallel sub-agents to design the interface several radically different ways, then compare on depth, locality, and seam placement.

© Prismer-AI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 13 other files (references) in sdk/cloud/catalog/skills/codebase-design of Prismer-AI/PrismerCloud.

  • SKILL.md
  • DEEPENING.md
  • DESIGN-IT-TWICE.md
  • LICENSE
  • references/requesting-code-review/GUIDE.md
  • references/requesting-code-review/LICENSE
  • references/requesting-code-review/LICENSE.superpowers
  • references/requesting-code-review/NOTICE.md
  • references/sdlc-review/GUIDE.md
  • references/sdlc-review/LICENSE
  • references/sdlc-review/NOTICE.md
  • references/simplify-code/GUIDE.md
  • references/simplify-code/LICENSE
  • references/simplify-code/NOTICE.md

Open the folder on GitHubat commit e5d9444

Compare with similar skills

Codebase Design next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Codebase Design compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Codebase Design this skillPrismer-AI/PrismerCloud1.6k—~1.7kAutomated safety check: PassMIT
Backend Code Reviewlanggenius/dify158k—~676Automated safety check: PassCustom licence
Code Review Skillawesome-skills/code-review-skill2.1k—~2.8kAutomated safety check: NotesMIT
Pascal Architecture PR Reviewpascalorg/editor25k—~7.5kAutomated safety check: PassMIT
Brooks Audithyhmrright/brooks-lint1.5k1 repos~537Automated safety check: PassMIT
Code Review SkillRain-kl/OpenFlare288—~2.3kAutomated safety check: NotesMIT

Similar skills

  • Backend Code Review

    langgenius/dify

    Reviews backend code under api/ for concrete, reproducible defects, routes to rule packs for architecture, schema, repositories and SQLAlchemy, and ranks findings from P0 to P3.

    158k GitHub stars~676 tokensUpdated today
    DevelopmentAuto-check passed

  • Code Review Skill

    awesome-skills/code-review-skill

    Provides comprehensive code review guidance for React 19, Vue 3, Angular 17+, Svelte 5, Rust, TypeScript, Java, Java 8, PHP, Ruby, Rails, Python, Django, FastAPI, Go, C/.NET, Kotlin, Swift, Dart…

    2.1k GitHub stars~2.8k tokensUpdated 29 days ago
    DevelopmentAuto-check: notes

  • Pascal Architecture PR Review

    pascalorg/editor

    Reviews a pull request against the Pascal editor's architectural rules: package boundaries, registry-driven node composition, hook hygiene and selector performance.

    25k GitHub stars~7.5k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Brooks Audit

    hyhmrright/brooks-lint

    Architecture audit that maps module dependencies, checks layering integrity, and flags structural decay across a codebase, drawing on twelve classic engineering books.

    1.5k GitHub starsUsed in 1 repo~537 tokens
    DevelopmentAuto-check passed

  • Code Review Skill

    Rain-kl/OpenFlare

    Provides comprehensive code review guidance for React 19, Vue 3, Angular 17+, Svelte 5, Rust, TypeScript, Java, PHP, Python, Django, Go, C/.NET, Kotlin, Swift, NestJS, C/C++, and more.

    288 GitHub stars~2.3k tokensUpdated today
    DevelopmentAuto-check: notes

  • Chisle Review

    JayPokale/Chisle

    Review a diff or file through the Chisle lens: flag over-engineering, speculative abstractions, reinvented stdlib, and verbose code that a lazier approach would shrink.

    628 GitHub stars~362 tokensUpdated yesterday
    DevelopmentAuto-check passed

More from Prismer-AI/PrismerCloud

All 88 skills in this repo

  • Prismer Google Workspace

    Prismer-AI/PrismerCloud

    Gives an agent account-scoped access to Gmail, Calendar, Drive, Contacts, Docs and Sheets through the gws CLI or a bundled Python client.

    1.6k GitHub starsUsed in 3 repos~4.2k tokens
    Auto-check passed

  • Prismer Skill Creator

    Prismer-AI/PrismerCloud

    Walks an agent through creating, importing, editing, validating, testing and publishing Prismer Skills with a fixed workflow and bundled scripts.

    1.6k GitHub stars~2.6k tokensUpdated 7 days ago
    Auto-check: notes

  • Himalaya Email CLI

    Prismer-AI/PrismerCloud

    Operates a mailbox from the terminal with the external Himalaya CLI over IMAP, SMTP, Notmuch or Sendmail, separate from any built-in email gateway adapter.

    1.6k GitHub starsUsed in 2 repos~2.3k tokens
    Auto-check passed

  • Prismer Image Generation

    Prismer-AI/PrismerCloud

    Generates one image from a text prompt with a bundled Node.js helper and delivers it once as the attachment to the current Prismer reply.

    1.6k GitHub stars~1.4k tokensUpdated 7 days ago
    Auto-check passed

  • Manim Explainer Videos

    Prismer-AI/PrismerCloud

    Produces 3Blue1Brown-style explainer animations with Manim Community Edition for math, algorithms, equations and architecture diagrams, with planning and rendering references.

    1.6k GitHub starsUsed in 2 repos~3.1k tokens
    Auto-check passed

  • Prismer Role Builder

    Prismer-AI/PrismerCloud

    Creates or updates Prismer role templates from a persona, SOP or job description, and turns a role into a working agent that runs its first task through a bundled script.

    1.6k GitHub stars~2.3k tokensUpdated 7 days ago
    Auto-check: notes

Categories

Questions about Codebase Design

What does Codebase Design do?

Designs deep modules with small interfaces, reviews scoped code changes and simplifies implementations while checking that behavior stays the same. The skill centers on deep modules: a lot of behavior placed behind a small interface at a clean seam, so it can be tested through that interface. It defines a shared vocabulary of module, interface, implementation, adapter and depth, and asks the agent to use those terms consistently instead of words like component or service.

When should I use Codebase Design?

Codebase Design fits situations like: designing the interface of a new module before implementing it; reviewing a scoped diff for behavioral defects; simplifying an implementation while confirming behavior is unchanged; making code easier to test through a smaller interface.

How do I install Codebase Design in Claude Code?

Run `npx skills add Prismer-AI/PrismerCloud --skill codebase-design -a claude-code`. Or copy the skill folder (sdk/cloud/catalog/skills/codebase-design in Prismer-AI/PrismerCloud) into .claude/skills/codebase-design in your project. Claude Code loads it when a task matches its description.

How do I install Codebase Design in Codex?

Run `npx skills add Prismer-AI/PrismerCloud --skill codebase-design -a codex`. Or copy the skill folder (sdk/cloud/catalog/skills/codebase-design in Prismer-AI/PrismerCloud) into .agents/skills/codebase-design in your project. Codex loads it when a task matches its description.

Can I use Codebase Design in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Prismer-AI/PrismerCloud --skill codebase-design -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/codebase-design, .gemini/skills/codebase-design, .github/skills/codebase-design and .opencode/skills/codebase-design in your project.

What does Codebase Design need to run?

SKILL.md names no scripts, command-line tools or credentials: Codebase Design is instructions for the agent only.

Does Codebase Design access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Codebase Design safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Codebase Design use?

Codebase Design is published under the MIT licence (from the LICENSE file in the skill folder). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Codebase Design use?

About 1.7k tokens (SKILL.md is roughly 7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 10k tokens, read only when the agent opens those files.

What are the alternatives to Codebase Design?

Skills that share tags, products or a category with Codebase Design: Backend Code Review (langgenius/dify, 158k stars), Code Review Skill (awesome-skills/code-review-skill, 2.1k stars), Pascal Architecture PR Review (pascalorg/editor, 25k stars) and Brooks Audit (hyhmrright/brooks-lint, 1.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Codebase Design?

Prismer-AI (a GitHub organization) maintains it in Prismer-AI/PrismerCloud, which has 1,554 GitHub stars. The repository holds 88 skills in this directory. The repository was last updated on September 30, 2026.

Source: Prismer-AI/PrismerCloud on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.