Skip to main content
skill CX Codex

minimum-viable — Claude Code skill: justify before you build

Makes the agent argue for its tooling and complexity level before any code appears. The simple version wins unless a concrete reason rules it out.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add ferrumclaudepilgrim/claude-code-android --skill minimum-viable -a claude-code
Open on GitHub

What minimum-viable does

The skill walks the agent through six questions up front. What is being built, in one sentence. What the simplest implementation looks like: a shell script, a single file, a few piped commands, a cron entry, a git hook. Why that simple version falls short, and the answer has to be concrete — not "it won't scale" but something like binary data or a persistent HTTP connection. No concrete reason means the agent stops at the simple version.

If the heavier route survives, the agent names the language, framework and every dependency, justifies each one, and checks that they are installed and working on the current OS and architecture. Maintenance cost gets weighed too: what breaks when a dependency updates, and who fixes it. The decision rule is blunt. Question three unanswered — build simple, done. Question three answered — go ahead, but write the reason into a comment or README so the next person understands why the complexity is there. An unverified dependency gets checked before work starts, or the design changes to avoid it.

The skill is invoked by hand and can read files, glob patterns, grep and run shell commands; it will not edit your code. The argument is whatever you are about to build. It earns its place on projects where the agent likes to spin up a framework for a twenty-line job — here that choice has to be defended in words.

What it helps with

  • Stop the agent from pulling in a framework for a twenty-line job
  • Confirm a dependency actually runs on your OS and architecture before starting
  • Record why a heavy construct exists in the project at all
  • Collapse a task into one file or a git hook instead of a separate service
  • Work out who repairs the build after a dependency update

Example prompts for the agent

  • Run the minimum-viable check on what I'm about to build: a log parser that sends Telegram alerts
  • Check the simplest option for a webhook that takes form submissions
  • Before writing code, justify the tool choice for this task

How to install minimum-viable

1Skills CLI (Vercel)

npx skills add ferrumclaudepilgrim/claude-code-android --skill minimum-viable -a claude-code

2Manually: put the files in place

~/.claude/skills/minimum-viable/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/minimum-viable/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about minimum-viable

How do I install minimum-viable in Claude Code?

Run npx skills add ferrumclaudepilgrim/claude-code-android --skill minimum-viable -a claude-code. The skill file lands at ~/.claude/skills/minimum-viable/SKILL.md.

What does the minimum-viable skill do?

It asks six questions about the task, the simplest implementation, the reason to skip it, dependencies and maintenance cost. Until question three has a concrete answer, the agent builds the simple version.

How is this different from ordinary planning?

Planning covers how to build something. This skill first demands proof that the heavy route is warranted, then has that reason written into a comment or README.

Source text

SKILL.md · MIT
---
name: minimum-viable
description: Before building anything, justify the tool choice and complexity level. Could a shell script do this? Does it need Node.js? A full application? Prevents over-engineering by requiring explicit justification before choosing a heavier approach.
user-invocable: true
disable-model-invocation: false
argument-hint: "<what you're about to build>"
allowed-tools: Read, Bash, Glob, Grep
---

# Minimum Viable Implementation Check

Answer every question before writing any code. If the simple version is sufficient, build that. Document why only if you choose a heavier approach.

## Required Questions

**1. What are you building?**
One sentence. If you cannot describe it in one sentence, the scope is not defined yet.

**2. What is the simplest possible implementation?**
Usually: a shell script, a single file, a few commands piped together, a cron entry, a git hook. Describe it. Estimate the line count.

**3. Why is the simple version insufficient?**
State a concrete reason. Not "it won't scale" but "it cannot handle binary data" or "it requires a persistent HTTP connection." If you cannot state a concrete reason, build the simple version.

**4. What is the proposed implementation?**
If you are not building the simple version: name the language, framework, and every dependency. Justify each one.

**5. Are dependencies available and working on this platform?**
For each dependency: is it installed? Does it work on the current OS and architecture? Have you verified this, or are you assuming? Check before committing to an approach.

**6. What is the maintenance cost?**
Will this break when a dependency updates? Who fixes it? If the answer is "whoever is here then," that is a cost. Weight it against the benefit of the heavier approach.

## Decision Rule

- If question 3 has no answer: build the simple version, stop here.
- If question 3 has an answer: proceed with the proposed implementation, but document the reason in a comment or README so the next person knows why the complexity exists.
- If question 5 reveals a missing dependency: verify availability before starting, or redesign to avoid it.

© ferrumclaudepilgrim · MIT · ferrumclaudepilgrim/claude-code-android

Similar skills

All skills for Agent setup: memory, context, orchestration →

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor