Skip to main content
skill CX Codex

coding · vicotrbb — Claude Code skill: what it does, how to install

coding is a Claude Code skill that enforces disciplined software changes. Loads before writing, debugging, refactoring, or reviewing code in any language.

Apache-2.0 ★ 121 updated 2026-11-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add vicotrbb/cubebot --skill coding -a claude-code
Open on GitHub

What coding does

The skill directs agents to solve only what was requested and keep code changes small. It bars unneeded abstractions, single-caller wrappers, and gratuitous packages, requiring the model to rely on existing codebase utilities or standard libraries first.

Debugging follows a test-first routine: find the root cause, write a reproduction, and stop after three failed attempts to reassess the problem. Completion claims are forbidden without fresh proof, such as current test runner outputs and build exit statuses.

What it helps with

  • keep pull requests focused on the exact user request
  • stop models from adding unneeded external dependencies
  • enforce bug reproduction with a failing test before patching
  • halt hallucinated fixes after three unsuccessful attempts

Example prompts for the agent

  • Follow coding guidelines and fix the session expiration issue
  • Refactor the billing module keeping the diff as small as possible
  • Review my changes according to the coding skill checklist

How to install coding

1Skills CLI (Vercel)

npx skills add vicotrbb/cubebot --skill coding -a claude-code

2Manually: put the files in place

~/.claude/skills/coding/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/coding/

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

Questions about coding

How to install coding in Claude Code?

Run npx skills add vicotrbb/cubebot --skill coding -a claude-code. The rule loads into ~/.claude/skills/coding/SKILL.md.

What does coding do?

It guides the agent to make minimal code modifications, reproduce defects with tests, match existing repository style, and supply proof before declaring tasks done.

When is the coding skill not needed?

Skip this skill when asking the assistant to explain or inspect code that you do not intend to modify.

Source text

SKILL.md · Apache-2.0
---
name: coding
description: How to change software so the change works and stays small. Load this before writing, fixing, refactoring, reviewing or debugging code in any language, including scripts, tests, configuration and build files, even for a change that looks like one line. Not needed to explain code you will not touch.
---

# Coding

You own the outcome, not the diff. A change is finished when you have watched it work, and the next reader can see why every line is there.

## Before you change anything

1. **Restate the goal as something you can check.** "Fix the login bug" becomes "signing in with an expired session redirects to /sign-in, and this test proves it". If you cannot write that sentence, you do not understand the task yet.
2. **Read the code you will touch and its callers.** Look for how this codebase already does the thing: a helper, a pattern, a naming habit. Find the project's own instructions and quality gate (README, CONTRIBUTING, justfile, Makefile, package scripts, CI config) and follow them.
3. **When something is unclear,** state your assumption and carry on if the work is easy to undo. Stop and ask only when the choice is irreversible, reaches outside the project, or two readings would produce very different work.

## While you change it

- **Do what was asked and only that.** Every changed line should trace back to the request. If you notice something else that is wrong, mention it rather than fixing it in passing.
- **Write the least code that fully solves the problem.** No option, abstraction, wrapper or configuration that this task does not use. A helper with one caller is usually just indirection. If it came out at 200 lines and could be 50, rewrite it.
- **Reach for what exists first:** this codebase, then the standard library, then a dependency already installed. Add a new dependency only when writing it yourself would be the larger risk, and pin it the way the project does.
- **Match the surrounding code:** its naming, layout, error style and comment density, even where you would have chosen differently.
- **Clean up only your own mess.** Remove the imports and helpers your change orphaned. Leave existing dead code, and never revert or reformat work you did not do.
- **Let failures show.** No catch-all handler, silent fallback, retry that hides an error, or type escape to quiet a compiler. Handle the errors you can act on and let the rest surface with their cause.
- **Comment why, not what,** and only where the code cannot say it. A known limit you are accepting gets a comment saying what the limit is and when to lift it.
- **Never cut these to save effort:** input validation at trust boundaries, authorization, secrets kept out of code and logs, and anything that could lose someone's data. Use parameterized queries, never string-built ones.

## Fixing a bug

Do not guess. Guess-and-patch is how a one-hour bug becomes a three-day one.

1. **Read the whole error,** including the stack trace and any earlier warning.
2. **Reproduce it,** ideally as a failing test. If you cannot reproduce it, say so and gather evidence; do not ship a theory.
3. **Trace it to where the bad value starts,** not where it crashes. Check what changed recently.
4. **Form one hypothesis and test it with one change.** Fix the cause once, in the shared code, after checking everything that calls it.
5. **After three failed fixes, stop.** Three misses mean your model of the system is wrong. Go back to the evidence, question the design, and tell the person what you have learned.

## Tests

- A test you have never seen fail proves nothing. Watch it fail for the expected reason first. For a regression test, undo the fix and confirm it goes red.
- Test behaviour through the public surface, using real collaborators where you can. A test that only asserts your mock was called is checking the mock.
- Add a test for new logic: a branch, a loop, a parser, anything touching money or security. Trivial changes need none.
- Never weaken, skip or delete a test to get to green unless it is genuinely wrong, and say so when you do.

## Before you say it is done

Claims need evidence you gathered just now:

| Claim                          | What proves it                                             |
| ------------------------------ | ---------------------------------------------------------- |
| Tests pass                     | The test command's output, this run, showing zero failures |
| It builds or type-checks       | That command's exit status, this run                       |
| The bug is fixed               | The reproduction now passes, and failed before the fix     |
| The feature works              | You ran it and saw the behaviour, not only its tests       |
| The other agent or tool did it | You read the resulting diff or output yourself             |

Run the project's whole gate, not just your new test, and read your own diff as a stranger would: anything unrequested, anything left over, anything you would question in review?

Then report plainly: what changed, what you ran and what it showed, what you did not check, and any risk the person should know. If a check failed or could not run, say that in the first line. "Should work" is not a result.

## When you are stuck

If you are re-reading the same files or retrying the same command without learning anything, you are not making progress. Change approach, or report what you tried and exactly what stopped you. Finish or explicitly drop every step you started; never leave work silently half done.

© vicotrbb · Apache-2.0 · vicotrbb/cubebot

Similar skills

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

coding by other authors comes first.

coding davidkiss coding is a Claude Code skill that sets general practices for writing and reviewing software. It activates for implementation, refactoring, and code review tasks. CX Codex +1 394installs general-best-practices Mindrally general-best-practices — a skill that hands your coding agent a set of rules on code quality, testing, security and architecture. Useful when you want consistent code across a project. CX Codex +1 840installs refactor-project FradSer refactor-project — a skill for Claude Code, Codex, Cursor and other agents that runs automated refactoring across every file in the project at once. Cuts duplication, normalises patterns, and strips legacy code in a single pass. CX Codex +1 122installs coding-standards affaan-m coding-standards is a Claude Code skill that sets conventions for naming, immutability, and clean code. Use it during code reviews and refactoring. CX Codex +1 7,900installs principal-engineering riekelt principal-engineering enforces core engineering discipline for AI agents: mandates pre-change checkpoints, bans silent error suppression, and requires evidence from real code. CX Codex +1 25,700installs improve-code-quality wondelai improve-code-quality — a skill for Claude Code and Codex guides untested code toward production stability. It runs an interactive nine-phase workflow and records every milestone in local markdown files. CX Codex +1 2,700installs gjalla-debug gjalla gjalla-debug — a skill that guides agents to find the root cause of a bug with evidence before proposing a fix. Works with Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode. CX Codex +1 357installs

From the same set5

Project sponsors

Companies that keep this analytics open