Skip to content
Skills Library
AI & agents · Learning & explanation

coding-discipline

/coding-discipline

Behavioral guardrails that reduce common AI coding mistakes: understand before implementing, write the minimum that solves the problem, change only what the task requires, and define verifiable success criteria. Apply this skill whenever writing, reviewing, refactoring, editing, or debugging code in any language -- even when the user does not explicitly ask for "discipline" or "best practices." Bias toward caution over speed; use judgment on trivial tasks.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Behavioral guardrails that reduce common AI coding mistakes: understand before implementing, write the minimum that solves the problem, change only what the task requires, and define verifiable success criteria. Apply this skill whenever writing, reviewing, refactoring, editing, or debugging code in any language -- even when the user does not explicitly ask for "discipline" or "best practices." Bias toward caution over speed; use judgment on trivial tasks.

Triggers from the description

disciplinebest practices.
Original author description

Behavioral guardrails that reduce common AI coding mistakes: understand before implementing, write the minimum that solves the problem, change only what the task requires, and define verifiable success criteria. Apply this skill whenever writing, reviewing, refactoring, editing, or debugging code in any language -- even when the user does not explicitly ask for "discipline" or "best practices." Bias toward caution over speed; use judgment on trivial tasks.

How it works

  1. 1. Understand Before Implementing
  2. 2. Write the Minimum
  3. 3. Change Only What's Needed
  4. 4. Define Success, Then Verify
Original SKILL.md headings · 71 lines, 421 words
SKILL.md preview
---
name: coding-discipline
description: >
  Behavioral guardrails that reduce common AI coding mistakes: understand before implementing, write the
  minimum that solves the problem, change only what the task requires, and define verifiable success
  criteria. Apply this skill whenever writing, reviewing, refactoring, editing, or debugging code in any
  language -- even when the user does not explicitly ask for "discipline" or "best practices." Bias
  toward caution over speed; use judgment on trivial tasks.
user-invocable: false
---

# Coding Discipline

Behavioral guardrails for working on code. They bias toward understanding, minimalism, precision, and
verification — the disciplines that separate a careful change from a sprawling one.

**Tradeoff:** these guardrails favor caution over speed. For trivial, unambiguous tasks, apply judgment
rather than ceremony.

## 1. Understand Before Implementing

**Don't assume. Don't hide confusion. Make tradeoffs visible.**

Before writing code:

- State your assumptions out loud. If a key one is uncertain, ask rather than guess.
- When a request has more than one reasonable interpretation, surface them — don't silently pick one.
- If a simpler path exists than the one requested, say so and push back when it's warranted.
- If something is genuinely unclear, stop and name exactly what's confusing instead of coding around it.

## 2. Write the Minimum

**The smallest code that solves the actual problem. Nothing speculative.**

- No functionality beyond what was asked.
- No abstractions for code that has a single caller.
- No "flexibility" or configuration that nobody requested.
- No error handling for conditions that cannot occur.
- If a solution runs long where it could be short, rewrite it shorter.

Sanity check: *would a senior engineer call this overcomplicated?* If yes, simplify before moving on.

## 3. Change Only What's Needed

**Touch what the task requires. Clean up only the mess you made.**

When editing existing code:

- Don't "improve" adjacent code, comments, or formatting that the task didn't touch.
- Don't refactor things that aren't broken.
- Match the surrounding style, even where you'd personally do it differently.
- Spot unrelated dead code? Mention it — don't delete it on your own initiative.

When your edits create orphans:

- Remove imports, variables, or functions that *your* change left unused.
- Leave pre-existing dead code alone unless asked to remove it.

The test: every changed line should trace directly back to the request.

## 4. Define Success, Then Verify

**Turn the task into something checkable. Loop until it passes.**

Restate vague tasks as verifiable goals:

- "Add validation" → write tests for the invalid inputs, then make them pass.
- "Fix the bug" → write a test that reproduces it, then make it pass.
- "Refactor X" → confirm the tests pass before and after.

For multi-step work, state a brief plan with a check per step:

```
1. [Step] -> verify: [check]
2. [Step] -> verify: [check]
3. [Step] -> verify: [check]
```

Strong success criteria let you iterate independently. Weak criteria ("make it work") force constant
back-and-forth.

Versions

RepositoryScoreLicence
This page · atc-net/atc-agentic-toolkit100MIT
imwhatiam/coding-discipline100MIT
jr2804/prompts100MIT
viktorbezdek/skillstack87MIT

Database snapshot: 13.11.2026 · package version 009b98169ecf (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100coding-guidelines
    Behavioral guidelines to reduce common LLM coding mistakes. Use when writing code, reviewing code, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria. Load with read_file on…
  • 100guidelines-karpathy
    Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
  • 100coding-guidelines
    Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
  • 100behavioral-guidelines
    Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
  • 100coding-guidelines
    Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, modifying, or reviewing code — implementation tasks, code changes, refactoring, bug fixes, or feature development. Do NOT use for architecture design, documentation, or non-code tasks.
  • 90behavioral-guardrails
    Core behavioral corrections for LLM coding. Reduces over-engineering, surfaces assumptions, enforces surgical changes, and defines verifiable success criteria. Use when writing code, reviewing code, fixing bugs, or implementing features.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.