Skip to content
Skills Library
AI & agents · Building & coding

simplify-skill

/simplify-skill

Use when simplifying a skill without losing behavior.

Repository
skills ↗
Licence
MIT
Last repository change
20.10.2026

Assessment and security

96/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability21 / 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
50
Scripts
19
HTML comments
0
URLs in SKILL.md
0
Deprecation

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

Licence

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

What to check before installing
  • 19 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/agentic_request_contract.py, scripts/check_code_rules.py, scripts/check_decision_records.py, scripts/check_domain_research.py, scripts/check_evals.py, scripts/check_improvement_contract.py, scripts/check_invocation_receipt.py, scripts/check_mise_primitives.py

What it does and when to use it

Use when simplifying a skill without losing behavior.

Original author description

Use when simplifying a skill without losing behavior.

How it works

  1. When to use
  2. Outcome
  3. Hard boundaries
  4. Required composition
  5. Input contract
  6. State machine
  7. Procedure
  8. Child extraction
  9. Acceptance
  10. Resources
Original SKILL.md headings · 99 lines, 814 words
SKILL.md preview
---
name: simplify-skill
description: 'Use when simplifying a skill without losing behavior.'
license: MIT
metadata:
  author: Kiren Srinivasan
  version: '0.1.1'
  scope: 'user'
---

# Simplify a skill

## When to use

Use this skill when an existing skill is harder to understand, operate, verify, or maintain than its domain requires. Do not use it for an ordinary code-only cleanup.

## Outcome

Reduce at least one declared complexity cost for a named actor and task. Preserve purpose, authority, behavior, safety, dependencies, outputs, and proof unless the user approves an exact loss.

Never accept line count alone as evidence of simplification.

## Hard boundaries

- Treat the complete current package as the baseline source of truth.
- Preserve essential domain complexity. Remove accidental complexity first.
- Default to lossless change.
- Keep exact commands, paths, schemas, hashes, quotes, permission gates, numeric limits, and stop rules exact.
- Keep component status separate from whole-skill status.
- Do not claim identical prose from every model or provider.
- Define determinism as a closed decision contract plus machine-checked end state.

## Required composition

Resource gate: run `mise run validate` before using package files named here.

Read the [dependency reconciliation](references/dependency-reconciliation.md) before changing a package. Use the collection's starting-point, human-behavior, agent-behavior, and meaning-preservation owners when their triggers apply.

A native host-only load is evidence, not a portable dependency. Internalize its invariant or route to an installed public peer. If neither is possible, return `BLOCKED_DEPENDENCY`.

## Input contract

Record `target`, `actor`, `task`, `environment`, `scope`, `invariants`, `measure`, and `allowed_loss`. Use `unknown` for missing data. `allowed_loss` is `none` unless the user approves an exact bound.

## State machine

Use only this order:

`DISCOVER -> BASELINE -> CONTRACT -> SELECT -> REWRITE -> VERIFY -> ACCEPT`

A gate failure moves to `BLOCKED`. Unapproved loss moves to `NEEDS_APPROVAL`. No accepted cost reduction moves to `NO_CHANGE`.

Resolve ties by authority, safety and privacy, behavior preservation, the user's exact method, lower declared cost, then `NO_CHANGE`.

## Procedure

1. **Discover.** Read the live target, every linked file, nearby owners, origin record, checks, and governing source. Stop on unexplained drift.
2. **Freeze.** Back up and hash every file. Run existing checks and representative tasks.
3. **Contract.** Give each rule and observable behavior a stable ID. Record authority, strength, conditions, protected spans, target, and evidence. Coverage must equal `1.0`.
4. **Select.** Try `deduplicate`, `clarify`, `reorder`, `progressive-disclosure`, `extract-child`, `simplify-code`, then `approved-loss`. Use the first mode that lowers the declared cost without a veto.
5. **Check claims.** Define the human or agent population and target test before claiming behavior improved.
6. **Rewrite.** Change the smallest owner. Use plain language, one rule per sentence, named actors, closed status words, defaults, and exact stop conditions.
7. **Handle code.** Use tests first and keep code proof separate from instruction proof.
8. **Verify.** Recompute hashes, ledger coverage, protected spans, links, metadata, loading, tests, package state, and end-state readback. Compare baseline and candidate in the same environment.
9. **Accept or restore.** Accept only when a declared cost fell, every invariant passed, and no veto remains. Otherwise restore or return the exact blocked status.

## Child extraction

Create a child only when it has a distinct trigger, standalone outcome, explicit interface, canonical ownership, direct tests, parent-route tests, expected reuse above coordination cost, and an acyclic load graph. Never split only to reduce line count.

## Acceptance

`ACCEPT` requires:

- baseline and candidate packet hashes recompute;
- ledger coverage is `1.0` with no unauthorized loss;
- every protected span passes or has exact approval;
- at least one declared cost decreases in the same environment;
- native, task, package, link, and readback checks pass;
- all ten native pressure cases retain their required and forbidden behavior.

Package PASS, eval enrollment, behavior-eval PASS, component status, and whole-skill PASS are separate results.

## Resources

- [Simplification model](references/simplification-model.md)
- [Preservation contract](references/preservation-contract.md)
- [Dependency reconciliation](references/dependency-reconciliation.md)
- `assets/` for ledger templates
- `examples/` for accepted and blocked outcomes
- `evals/` for native-case lineage and portable tests
- `mise run test` for package checks

## Factory execution contract

The accepted outcome is: Reduce skill complexity while proving semantic parity and preserving every accepted behavior. Preserve current behavior-preserving simplification behavior while changing its smallest owner.

1. Freeze the current package with `mise run ci` and record its digest.
2. Run `mise run domain-research-policy`, then judge the current behavior-preserving simplification sources and counterevidence.
3. Run `mise run agentic-request` for the named behavior-preserving simplification operation. Keep semantic choices with the model.
4. Run `mise run decision-policy`, `mise run ci`, and the behavioral evals. Return to the lowest failed owner.
5. Run `mise run invocation-policy -- <receipt>` and account for every task or its domain-specific non-use.
6. Optionally run `mise run improvement-policy`. Keep one changed dimension only if no protected dimension regresses.

Load `assets/use-case-contract.json` through `mise run use-case-policy` and `evals/evals.json` through `mise run evals` only when their contracts are needed.

Mise owns repeatable mechanics, ordering, receipts, and checks. The model owns interpretation, causal judgment, creative work, and direct perception that code cannot supply. Stop on missing authority, stale evidence, or a failed gate.
Files in this package (50)
  • SKILL.md 6 KB
  • mise.toml 3 KB
  • .github/workflows/ci.yml 1 KB
  • assets/decision-records.json 3 KB
  • assets/improvement-contract.json 3 KB
  • assets/invocation-receipt-template.json 1 KB
  • assets/ledger-template.json 1 KB
  • assets/mise-primitives-catalog.json 2 KB
  • assets/mise-primitives.json 4 KB
  • assets/primitive-lifecycle.json 7 KB
  • assets/use-case-contract.json 26 KB
  • evals/cases.json 8 KB
  • evals/contract.md 1 KB
  • evals/evals.json 5 KB
  • evals/manifest.json 1 KB
  • evals/rubric.md 1 KB
  • evals/source-lineage.json 6 KB
  • evals/source-mapping.json 289 KB
  • evals/speed-budgets.json 1 KB
  • evals/trigger-cases.json 1 KB
  • evals/trigger-queries.json 1 KB
  • examples/accepted-deduplication.md 1 KB
  • examples/blocked-contradiction.md 1 KB
  • examples/no-change.md 1 KB
  • references/decisions.md 1 KB
  • references/dependency-reconciliation.md 1 KB
  • references/generation-contract.md 19 KB
  • references/preservation-contract.md 1 KB
  • references/resource-and-experiment-design.md 13 KB
  • references/simplification-model.md 1 KB
  • references/use-case-specificity.md 6 KB
  • scripts/agentic_request_contract.py 7 KB
  • scripts/check_code_rules.py 4 KB
  • scripts/check_decision_records.py 4 KB
  • scripts/check_domain_research.py 7 KB
  • scripts/check_evals.py 4 KB
  • scripts/check_improvement_contract.py 4 KB
  • scripts/check_invocation_receipt.py 4 KB
  • scripts/check_mise_primitives.py 5 KB
  • scripts/check_placeholders.py 4 KB
  • scripts/check_primitive_lifecycle.py 5 KB
  • scripts/check_task_graph.py 8 KB
  • scripts/check_use_case_contract.py 6 KB
  • scripts/domain_text.py 1 KB
  • scripts/lint_writing.py 8 KB
  • scripts/run_agentic_request.py 2 KB
  • scripts/sync_mise_primitives.py 4 KB
  • scripts/validate_skill.py 4 KB
  • scripts/tests/test_ci_contract.py 1 KB
  • scripts/tests/test_source_mapping.py 2 KB

Versions

The database has no other skills named simplify-skill.

Database snapshot: 13.11.2026 · package version fab58aab3ba9 (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

  • 100skill-simplify
    SKILL.md simplification with functional integrity verification. Analyze redundancy, optimize content, check no functionality lost. Triggers on "simplify skill", "optimize skill", "skill-simplify".
  • 95simplify
    Use when the user wants to simplify or clean up code without changing behavior. Accepts standalone scope or user-selected findings from /refactor.
  • 100simplify-spec
    Simplify a design specification in Specs/ to focus on user-facing behavior. Use when asked to: "simplify a spec", "clean up a spec", "remove implementation details from a spec", "make a spec more high-level", "simplify the spec for [feature]", "rewrite spec to be user-facing",…
  • 100dx-simplify
    Simplify working code without changing its behavior — Chesterton's Fence, Rule of 500. Use for 'simplify', 'reduce complexity', 'refactor for clarity'.
  • 90simplify
    Simplifies code for clarity without changing behavior. Use for readability, maintainability, and complexity reduction after behavior is understood.
  • 90code-simplifier
    Simplify existing code for clarity and maintainability without changing behavior. Use when asked to clean up or simplify code, especially recent changes.

Feedback and reports

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