Skip to main content
skill CX Codex

team-discipline — Claude Code skill: what it does and how to install

team-discipline is a Claude Code skill that sets the default rules for coding tasks. It asks the agent to inspect the code first, make a minimal complete change, and verify the result.

MIT ★ 71 updated 2026-11-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add sametcelikbicak/opencode-team --skill team-discipline -a claude-code
Open on GitHub

What team-discipline does

team-discipline guides code changes from inspection to verification. The agent traces the affected code and its callers, checks for existing solutions, then makes the smallest complete change. For new behavior, it starts with a test that fails for the intended reason and runs it again after the implementation. Trivial one-line changes do not need a test.

For large or risky work, the agent states the plan, verification method, and rollback path before editing. Destructive changes, trust-boundary changes, and design ambiguity require approval. The final report names the changes and checks; an unrun command cannot be reported as a passing result.

What it helps with

  • trace callers before fixing a shared function
  • keep a code change limited to the task
  • test new behavior before and after implementation
  • report command output and remaining risks

Example prompts for the agent

  • Fix the input-handling bug and trace every caller of the function.
  • Add the new behavior with a test that fails first.
  • Review these changes and report which checks you ran.

How to install team-discipline

1Skills CLI (Vercel)

npx skills add sametcelikbicak/opencode-team --skill team-discipline -a claude-code

2Manually: put the files in place

~/.claude/skills/team-discipline/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/team-discipline/

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

Questions about team-discipline

How do I install team-discipline in Claude Code?

Run npx skills add sametcelikbicak/opencode-team --skill team-discipline -a claude-code. The skill file is at ~/.claude/skills/team-discipline/SKILL.md.

What does team-discipline do?

It sets a working standard for code tasks: inspect the project, make the smallest complete change, and verify it with evidence. The agent ends with a short report.

When does team-discipline apply?

It applies to coding, bug fixes, refactoring, reviews, and build, QA, security, or documentation work that touches source code.

Source text

SKILL.md · MIT
---
name: team-discipline
description: >-
  Use on every coding task to apply the team's default engineering discipline:
  understand before changing, YAGNI, the smallest complete change, test-first,
  evidence before claims, and a short report. This is default behavior, not an
  optional mode.
---

# Engineering Discipline

Default behavior for every agent that writes or reviews code. The goal is the smallest change that fully solves the task, not the most code.

The best code is the code never written. But lazy means efficient, not careless: a small change in the wrong place is a second bug.

## When to use

- Any task that writes, fixes, refactors, reviews or chooses a dependency.
- Any build, QA, security or docs stage that touches source code.
- Not only when the user says "simple", "minimal" or "YAGNI". This is the baseline.

The stage playbook (`team-build`) wins on TDD mechanics. This skill sets the default standard every role applies.

## 1. Understand before changing

Read the task and the code it touches. Trace the real flow end to end before choosing an approach.

List the blast radius:

- callers of every function you change;
- tests, fixtures and snapshots that depend on the behavior;
- config, exports, types and public interfaces;
- data the change could destroy or expose;
- callers that would stop working.

That list is the scope. Extra features are not scope.

If the request is ambiguous in a way that changes the design, ask one short question. Do not guess and rewrite later.

## 2. The ladder

Stop at the first rung that holds:

1. Does this need to exist at all? Skip features, options and flexibility nobody asked for.
2. Does it already exist in this codebase? Reuse the helper, util, component or pattern.
3. Does the standard library already do this? Use it.
4. Does a native platform feature cover it? Use it.
5. Does an already-installed dependency solve it? Use it.
6. Can it be one clear line? Make it one line.
7. Only then: write the minimum code that works.

The ladder runs after you understand the problem, not instead of it.

## 3. The smallest complete change

- No abstraction, wrapper, type conversion, option, config or "for later" code nobody asked for.
- No new dependency if it can be avoided.
- No boilerplate nobody asked for.
- Deletion beats addition. Boring beats clever. Fewest files possible.
- Keep the structure the codebase already has: its layers, interfaces and conventions.
- Keep values in the form the platform already gives you.
- Comment only the *why* the code cannot show, in one line.

A change is complete only when every part the task needs is done: callers, tests, fixtures, config and docs your change breaks or requires.

### Bug fixes

A report names a symptom. Find the root cause, grep every caller of the function you touch, and fix the shared function once. One guard there is smaller than one guard per caller, and patching only the named path leaves a sibling caller broken.

### Preserve what protects users

Code you move, merge or rewrite keeps its input validation, error handling and access checks.

## 4. Test-first

For new behavior:

1. Write the smallest test that fails for the right reason.
2. Run it and confirm it fails.
3. Write the minimum code to pass.
4. Run it and confirm it passes.
5. Refactor with the test green.

Non-trivial logic leaves one runnable check behind: the smallest thing that fails if the logic breaks. That can be a small test file, an assert-based self-check or a demo script. No framework, fixtures or test pyramid is required for a small change.

Trivial one-liners need no test.

Test the behavior at the boundary, not the implementation detail. Keep tests deterministic. Mock only what you do not own (network, clock, filesystem, third-party service).

## 5. Evidence before claims

- Run the command before saying it passes.
- Quote the real output, not a paraphrase.
- If it was not run, write "not run". Never invent command output, metrics or test results.
- A claim of "fixed" needs the failing case to pass now.
- Do not claim a stage is complete while a requested specialist is missing, failed or cancelled.

## 6. Design gate

For a large or risky change, state the plan before editing:

- the files you will touch;
- the approach and the alternative you rejected;
- how you will verify it;
- the rollback path if it changes data or deployment.

Ask for approval when the change is destructive, crosses a trust boundary, or the request has real ambiguity. Otherwise proceed and report.

## 7. Report

End with a short report a busy human can read once:

- what changed and why;
- what now works, concretely;
- the evidence (command and result);
- known gaps, shortcuts and risks;
- one concrete next action when something remains.

One or two lines for what you skipped or did not check, and any risk the user must know.

## Not lazy about

Never cut these to save code:

- input validation at trust boundaries;
- error handling that prevents data loss;
- security and authorization;
- accessibility;
- calibration that real hardware needs;
- anything the user explicitly requested.

## Deliberate shortcuts

A shortcut with a known ceiling gets a code comment in this form:

```text
shortcut: <the limit>, <when to upgrade>
```

Example: `shortcut: global lock, replace with per-key locks when writes exceed ~100/s`.

An unmarked shortcut is a hidden bug.

## Common mistakes

| Mistake | Fix |
| --- | --- |
| Patching the reported caller only | Grep every caller and fix the shared function. |
| Building a config option nobody asked for | Delete it; add it when a real caller needs it. |
| Adding a dependency for a few lines | Use the standard library or an installed package. |
| Writing code before tracing the flow | Read the callers and tests first. |
| Claiming tests pass without running them | Run them and quote the output, or write "not run". |
| A test that passes before the fix | Make it fail for the right reason first. |
| Hiding a known limit | Mark it with `shortcut:` and name the upgrade path. |
| Rewriting unrelated code in the same change | Keep the diff to the task. |

## Relationship to other skills

- `team-build` — red-green-refactor, seams and the test pyramid for the build stage.
- `team-memory` — record durable decisions and lessons, not transcripts.
- Stage playbooks — the role's methodology; this skill is the default standard on top of it.

© sametcelikbicak · MIT · sametcelikbicak/opencode-team

Similar skills

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

From the same set25

The whole set →
team-market-research team-market-research is a Claude Code skill that structures market, competitor, and user research. Guides niche validation, source hierarchy checks, and product risk evaluations. CX Codex +1 ★ 71repo stars team-architecture team-architecture is a Claude Code skill for planning software architecture, from data models and API contracts to module boundaries and risks. It activates for architecture design requests. CX Codex +1 ★ 71repo stars team-security-review team-security-review is a Claude Code skill that enforces a strict security auditing playbook. It inspects authentication flows, access control, input handling, and secret leaks. CX Codex +1 ★ 71repo stars team-backlog team-backlog is a Claude Code skill that turns a PRD into vertical tickets with acceptance criteria and dependencies. It writes the approved plan to .team/03-backlog.md. CX Codex +1 ★ 71repo stars team-release team-release is a Claude Code skill that turns a release into ordered steps: a Semver bump with a reason, changelog, CI stages, deploy commands and a rollback table. It switches on when a project is ready to tag and ship. CX Codex +1 ★ 71repo stars team-build team-build is a Claude Code skill that enforces TDD workflows, test seams, and deterministic test suites. It guides code changes against ticket acceptance criteria before QA handoff. CX Codex +1 ★ 71repo stars team-brand team-brand is a Claude Code skill for developing brand identities and logos, from a brief through concepts and a brand guide. It can also critique an existing mark or create icon assets. CX Codex +1 ★ 71repo stars team-memory team-memory is a Claude Code skill that stores project context and decisions in local .team/memory files. Runs at task boundaries, during /memory calls, and when resuming interrupted pipelines. CX Codex +1 ★ 71repo stars

Project sponsors

Companies that keep this analytics open