base
by alinaqiThe base skill is a foundation for code editing, using TDD-first habits, atomic todos, and strict simplicity rules to keep changes small, readable, and low-risk.
This skill scores 68/100. It is worth listing because it gives agents a concrete, reusable base for coding constraints and TDD-oriented behavior, but users should treat it as a foundation layer rather than a fully packaged workflow skill. The directory listing would help users decide that it is installable if they want broad default coding rules, while also warning them that some adoption details are still thin.
- Clearly positioned as a universal foundation: "always loaded as foundation for all projects" with TDD workflow, simplicity rules, and atomic todos.
- Substantial operational detail: long SKILL.md with many headings, constraints, and workflow guidance instead of a placeholder stub.
- Good triggerability for agents: explicit when-to-use guidance and direct coding constraints make the intended behavior easier to invoke than a generic prompt.
- No install command, scripts, or support files, so adoption depends almost entirely on the SKILL.md content.
- Contains placeholder markers like "todo" and no separate references/resources, which lowers trust in edge-case completeness.
Overview of base skill
What the base skill does
The base skill is a foundation layer for coding work: it pushes simple structure, TDD-first habits, and atomic tasking before you drift into overengineering. If you want a base skill that helps an agent make smaller design choices, keep files readable, and reduce rewrite risk, this is aimed at that job.
Best-fit users
Use the base skill when you need a practical guardrail for day-to-day implementation, especially in greenfield repos, refactors, or AI-assisted coding sessions where scope can expand too fast. It is most useful for teams that care about maintainability more than cleverness.
What makes it different
The strongest signal in this base guide is not a fancy framework; it is hard limits and enforcement. The repo emphasizes simplicity rules, line-count constraints, file boundaries, and a TDD workflow so the agent has fewer degrees of freedom. That makes base for Code Editing better suited to consistent edits than open-ended brainstorming.
How to Use base skill
Install and load it correctly
For the directory entry, the intended install path is npx skills add alinaqi/claude-bootstrap --skill base. Because the skill is marked always-loaded in the source, treat base install as a foundation you want active before you start editing, not as a one-off prompt snippet.
Turn a rough task into a good prompt
Base works best when your prompt states the target file, the change goal, and the constraint class. A weak request like “clean this up” invites broad rewrites; a stronger base usage prompt is: “Refactor src/auth/session.ts to separate validation from persistence, keep each function under 20 lines, preserve current tests, and add tests first for the new error cases.”
Read these files first
Start with SKILL.md to understand the rules, then inspect the rest of the repo for adjacent conventions before you edit. In this repository, there are no helper folders like rules/ or resources/, so the main decision surface is the skill file itself and any project files in the target codebase.
Workflow that fits the skill
Use base as a sequence: identify the smallest change, write or update tests, implement in compact functions, then check line and dependency limits before finishing. If the task cannot be made small enough, split it into multiple atomic todos instead of forcing a large patch through one pass.
base skill FAQ
Is base skill useful by itself?
Yes, if you want a coding baseline rather than a domain-specific tool. The base skill is designed to be broadly applicable, but it is strongest when paired with a clear project prompt and existing repo context.
When should I not use base?
Do not use it when the task is exploratory, highly visual, or intentionally prototype-heavy and you do not care about structure yet. If your goal is speed at any cost, the base skill’s constraints may feel restrictive.
Is this better than a normal prompt?
Usually yes for code editing work, because the base guide gives the agent concrete boundaries instead of vague style advice. A plain prompt can say “write clean code,” but base adds measurable constraints like function size, nesting depth, and file scope.
Is base suitable for beginners?
Yes, because the rules are explicit and easy to check. The main beginner risk is overapplying the limits without understanding the problem, so start with the smallest useful change rather than refactoring everything at once.
How to Improve base skill
Give the skill sharper inputs
The best way to improve base results is to name the file, the intended behavior, and the boundary of the edit. “Fix the login flow” is weak; “Update login.ts so token parsing is isolated, add tests for expired tokens, and keep the public API unchanged” gives the skill a clearer target.
Ask for the right tradeoff
If readability matters more than minimal diff size, say so. If tests must be updated before implementation, say that too. The base skill responds better when you tell it which constraint is non-negotiable instead of assuming it will infer priorities.
Review for the common failure modes
Watch for over-splitting, hidden coupling, and edits that satisfy the line-count rules but weaken naming or module boundaries. If the first pass is too abstract or too fragmented, ask for a second pass that merges trivial helpers, removes redundancy, and keeps the path of execution obvious.