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

Design Interface

by danielvm-git in danielvm-git/bigpowers

Generate multiple radically different interface designs for a module using parallel sub-agents, then compare trade-offs.

MITAuto-check passedBackend & APIs

Install Design Interface

skills CLI
$ npx skills add danielvm-git/bigpowers --skill design-interface -a claude-code

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

GitHub CLI
$ gh skill install danielvm-git/bigpowers design-interface --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/danielvm-git/bigpowers.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/design-interface .claude/skills/design-interface && 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
design-interface
GitHub stars
256
Token cost
~914 tokens
SKILL.md length
344 words
Files
1
Skills in repo
39
Repo updated
First seen
Licence
MIT

At a glance

Generate multiple radically different interface designs for a module using parallel sub-agents, then compare trade-offs.

  • Works in 5 steps: Gather Requirements → Generate Designs (Parallel Sub-Agents) → Present Designs → …
  • User wants to design an API
  • SKILL.md covers Workflow, Evaluation Criteria and Anti-Patterns
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Design Interface is an agent skill from danielvm-git/bigpowers. Generate multiple radically different interface designs for a module using parallel sub-agents, then compare trade-offs. Based on "Design It Twice" from A Philosophy of Software Design. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

Its SKILL.md is about 910 tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering API design and Subagents. The repository describes itself as: Agent skills synthesizing years of software engineering discipline into a prescriptive methodology for solo developers. The licence is MIT.

When your agent uses it

  • User wants to design an API
  • Explore interface options
  • Compare module shapes
  • Mentions design it twice

Example prompts

  • “Design It Twice”
  • “design it twice”
  • “/design-interface”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Gather Requirements
  2. Generate Designs (Parallel Sub-Agents)
  3. Present Designs
  4. Compare Designs
  5. Synthesize

What it can do on your machine

Read from SKILL.md and the folder at commit 812d57a. 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.

    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

Design Interface loads about 914 tokens when it runs. Until then it costs about 80 tokens; SKILL.md has 344 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~80
When it runs · the whole SKILL.md, loaded when a task matches
~914

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 danielvm-git/bigpowers at commit 812d57a, republished under its MIT licence (© danielvm-git). 344 words, ~914 tokens.

Download SKILL.mdSave it as .claude/skills/design-interface/SKILL.md (or your agent's skills folder).
name
design-interface
description
Generate multiple radically different interface designs for a module using parallel sub-agents, then compare trade-offs. Based on "Design It Twice" from A Philosophy of Software Design. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".
model
opus
effort
standard

Design Interface

Based on "Design It Twice" from "A Philosophy of Software Design": your first idea is unlikely to be the best. Generate multiple radically different designs, then compare.

HARD GATE — Multiple design options must be explored. Do NOT settle on first idea. Compare trade-offs (UX, complexity, extensibility, performance) before committing.

Workflow

1. Gather Requirements

Before designing, understand:

  • What problem does this module solve?
  • Who are the callers? (other modules, external users, tests)
  • What are the key operations?
  • Any constraints? (performance, compatibility, existing patterns)
  • What should be hidden inside vs exposed?

Ask: "What does this module need to do? Who will use it?"

2. Generate Designs (Parallel Sub-Agents)

Spawn 3+ sub-agents simultaneously using Task tool. Each must produce a radically different approach.

Prompt template for each sub-agent:

Design an interface for: [module description]

Requirements: [gathered requirements]

Constraints for this design: [assign a different constraint to each agent]
- Agent 1: "Minimize method count - aim for 1-3 methods max"
- Agent 2: "Maximize flexibility - support many use cases"
- Agent 3: "Optimize for the most common case"
- Agent 4: "Take inspiration from [specific paradigm/library]"

Output format:
1. Interface signature (types/methods)
2. Usage example (how caller uses it)
3. What this design hides internally
4. Trade-offs of this approach
3. Present Designs

Show each design with:

  1. Interface signature — types, methods, params
  2. Usage examples — how callers actually use it in practice
  3. What it hides — complexity kept internal

Present designs sequentially so user can absorb each approach before comparison.

4. Compare Designs

After showing all designs, compare them on:

  • Interface simplicity: fewer methods, simpler params
  • General-purpose vs specialized: flexibility vs focus
  • Implementation efficiency: does shape allow efficient internals?
  • Depth: small interface hiding significant complexity (good) vs large interface with thin implementation (bad)
  • Ease of correct use vs ease of misuse

Discuss trade-offs in prose, not tables. Highlight where designs diverge most.

5. Synthesize

Often the best design combines insights from multiple options. Ask:

  • "Which design best fits your primary use case?"
  • "Any elements from other designs worth incorporating?"

Evaluation Criteria

From "A Philosophy of Software Design":

Interface simplicity: Fewer methods, simpler params = easier to learn and use correctly.

General-purpose: Can handle future use cases without changes. But beware over-generalization.

Implementation efficiency: Does interface shape allow efficient implementation? Or force awkward internals?

Depth: Small interface hiding significant complexity = deep module (good). Large interface with thin implementation = shallow module (avoid).

Anti-Patterns

  • Don't let sub-agents produce similar designs — enforce radical difference
  • Don't skip comparison — the value is in contrast
  • Don't implement — this is purely about interface shape
  • Don't evaluate based on implementation effort

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

Files

Just SKILL.md in skills/design-interface of danielvm-git/bigpowers.

Open the folder on GitHubat commit 812d57a

Compare with similar skills

Design Interface 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.

Design Interface compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Design Interface this skilldanielvm-git/bigpowers256—~914Automated safety check: PassMIT
Design An Interfacefossasia/eventyay-interpretation1.6k9 repos~842Automated safety check: PassApache-2.0
Feature TrackingJunsW/feature-track108—~339Automated safety check: PassMIT
Auditaustintgriffith/ethskills294—~829Automated safety check: PassNone
Spec Contract Compliance Reviewbbartling/open-fdd172—~1.4kAutomated safety check: PassCustom licence
API DesignerJeffallan/claude-skills12k2 repos~2kAutomated safety check: PassMIT

Similar skills

  • Design An Interface

    fossasia/eventyay-interpretation

    Generate multiple radically different interface designs for a module using parallel sub-agents.

    1.6k GitHub starsUsed in 9 repos~842 tokens
    Backend & APIsAuto-check passed

  • Feature Tracking

    JunsW/feature-track

    Maintain portable Feature Track docs for project features. An agent skill from JunsW/feature-track.

    108 GitHub stars~339 tokensUpdated 2 mo ago
    Backend & APIsAuto-check passed

  • Audit

    austintgriffith/ethskills

    Deep EVM smart contract security audit system. An agent skill from austintgriffith/ethskills.

    294 GitHub stars~829 tokensUpdated 1 mo ago
    Backend & APIsAuto-check passed

  • Spec Contract Compliance Review

    bbartling/open-fdd

    A skill your agent uses to compare any codebase against a specification, API contract, protocol, policy, RFC, security baseline, or product requirements document.

    172 GitHub stars~1.4k tokensUpdated yesterday
    Legal & ComplianceAuto-check passed

  • API Designer

    Jeffallan/claude-skills

    Designs REST and GraphQL APIs from resource modeling to an OpenAPI 3.1 contract, with versioning, pagination and RFC 7807 error handling.

    12k GitHub starsUsed in 2 repos~2k tokens
    Backend & APIsAuto-check passed

  • Nodejs Backend Patterns

    ever-works/ever-works

    Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices.

    158 GitHub starsUsed in 17 repos~4k tokens
    Backend & APIsAuto-check passed

More from danielvm-git/bigpowers

All 39 skills in this repo

  • Extract Design

    danielvm-git/bigpowers

    Extract a Google DESIGN.md file from an HTML prototype (claude.ai/design or any styled page) using Puppeteer, producing machine-readable tokens and AI-generated prose.

    256 GitHub stars~1k tokensUpdated 16 days ago
    Auto-check passed

  • Align Grid

    danielvm-git/bigpowers

    Build editorial/magazine/report webpages on a GENUINE Müller-Brockmann modular grid (International Typographic Style) — not a decorative one.

    256 GitHub stars~3k tokensUpdated 16 days ago
    Auto-check passed

  • Assess Impact

    danielvm-git/bigpowers

    Analyze the blast radius of a proposed change before any code is written.

    256 GitHub stars~766 tokensUpdated 16 days ago
    Auto-check passed

  • Audit Code

    danielvm-git/bigpowers

    Self-review checklist for the coding agent to run before dispatching a reviewer.

    256 GitHub stars~1.6k tokensUpdated 16 days ago
    Auto-check: notes

  • Audit Plan

    danielvm-git/bigpowers

    Evaluate an incoming project plan against bigpowers principles and conventions, surface gaps, and produce a READY/NOT READY verdict before engagement begins.

    256 GitHub stars~880 tokensUpdated 16 days ago
    Auto-check passed

  • Compose Workflow

    danielvm-git/bigpowers

    Chain multiple bigpowers skills into a custom workflow recipe saved in specs/.

    256 GitHub stars~723 tokensUpdated 16 days ago
    Auto-check passed

Categories

Questions about Design Interface

What does Design Interface do?

Generate multiple radically different interface designs for a module using parallel sub-agents, then compare trade-offs. Design Interface is an agent skill from danielvm-git/bigpowers. Generate multiple radically different interface designs for a module using parallel sub-agents, then compare trade-offs.

When should I use Design Interface?

Design Interface fits situations like: user wants to design an API; explore interface options; compare module shapes; mentions design it twice.

How do I install Design Interface in Claude Code?

Run `npx skills add danielvm-git/bigpowers --skill design-interface -a claude-code`. Or copy the skill folder (skills/design-interface in danielvm-git/bigpowers) into .claude/skills/design-interface in your project. Claude Code loads it when a task matches its description.

How do I install Design Interface in Codex?

Run `npx skills add danielvm-git/bigpowers --skill design-interface -a codex`. Or copy the skill folder (skills/design-interface in danielvm-git/bigpowers) into .agents/skills/design-interface in your project. Codex loads it when a task matches its description.

Can I use Design Interface 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 danielvm-git/bigpowers --skill design-interface -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/design-interface, .gemini/skills/design-interface, .github/skills/design-interface and .opencode/skills/design-interface in your project.

What does Design Interface need to run?

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

Does Design Interface 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 Design Interface 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 Design Interface use?

Design Interface is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Design Interface use?

About 914 tokens (SKILL.md is roughly 3.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Design Interface?

Skills that share tags, products or a category with Design Interface: Design An Interface (fossasia/eventyay-interpretation, 1.6k stars), Feature Tracking (JunsW/feature-track, 108 stars), Audit (austintgriffith/ethskills, 294 stars) and Spec Contract Compliance Review (bbartling/open-fdd, 172 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Design Interface?

danielvm-git (a GitHub user) maintains it in danielvm-git/bigpowers, which has 256 GitHub stars. The repository holds 39 skills in this directory. The repository was last updated on September 21, 2026.

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