Skip to content
Skills Library
Programming · Review & audit

decomplect

/decomplect

Review code and architecture for accidental complexity, mixed pure logic and effects, weak boundaries, and harmful coupling. Use for design reviews, architecture assessments, pre-refactor analysis, pull-request review, or questions about simplicity, functional core/imperative shell, cohesion, dependency direction, and Rich Hickey's decomplection principles. Works across programming languages and mixed-language repositories.

Repository
skills ↗
Licence
MIT
Last repository change
15.07.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
9
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 15.07.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

Review code and architecture for accidental complexity, mixed pure logic and effects, weak boundaries, and harmful coupling. Use for design reviews, architecture assessments, pre-refactor analysis, pull-request review, or questions about simplicity, functional core/imperative shell, cohesion, dependency direction, and Rich Hickey's decomplection principles. Works across programming languages and mixed-language repositories.

Original author description

Review code and architecture for accidental complexity, mixed pure logic and effects, weak boundaries, and harmful coupling. Use for design reviews, architecture assessments, pre-refactor analysis, pull-request review, or questions about simplicity, functional core/imperative shell, cohesion, dependency direction, and Rich Hickey's decomplection principles. Works across programming languages and mixed-language repositories.

How it works

  1. Select the scope
  2. Apply the review lenses
  3. Remain language-agnostic
  4. Validate candidates
  5. Report findings
  6. Claude Code adapter
Original SKILL.md headings · 104 lines, 713 words
SKILL.md preview
---
name: decomplect
description: Review code and architecture for accidental complexity, mixed pure logic and effects, weak boundaries, and harmful coupling. Use for design reviews, architecture assessments, pre-refactor analysis, pull-request review, or questions about simplicity, functional core/imperative shell, cohesion, dependency direction, and Rich Hickey's decomplection principles. Works across programming languages and mixed-language repositories.
---

# Decomplect

Review architecture through three complementary lenses:

- **Simplicity:** Are independent concerns intertwined?
- **Functional core / imperative shell:** Is deterministic policy separated from effects?
- **Cohesion and coupling:** Do boundaries group related behavior and constrain dependencies?

Perform a review by default. Do not edit code unless the user explicitly asks for changes.

## Select the scope

Honor an explicit user-provided review scope before applying defaults. Accept files,
directories, snippets, diffs, commits, branches, pull-request refs, or the whole repository.
A comparison-base option by itself configures branch comparison; it is not a review scope.

When the user does not specify a scope:

1. In a Git repository, inspect working-tree changes relative to `HEAD`.
2. If the working tree is clean, resolve the comparison base in this order: a comparison-base
   option supplied by the user, the remote's symbolic default branch, then the configured
   upstream when no remote default can be determined. Never assume `main`.
3. Compute the merge base between that ref and `HEAD`, then review from the merge base through
   `HEAD`. This includes already-pushed feature commits instead of comparing a feature branch
   only with its same-named remote tracking branch.
4. If no base or meaningful diff can be determined, ask for a scope or report that there is
   nothing to review.
5. Outside Git with no explicit review scope, ask the user for files, a directory, a diff, or a
   snippet to review.

Read enough surrounding code, tests, configuration, and documentation to validate each
finding. Distinguish problems introduced by the selected changes from relevant pre-existing
context. Exclude generated, vendored, minified, lock, and snapshot files unless requested.

## Apply the review lenses

Run all three lenses unless the user selects one. If independent workers or subagents are
available, the lenses may run in parallel with the same scope. Otherwise, run them
sequentially. Parallelism is an optimization, not a requirement.

1. Read [simplicity.md](references/simplicity.md) for intertwined concerns, hidden state,
   ordering, and incidental mechanisms.
2. Read [functional-core.md](references/functional-core.md) for policy/effect separation,
   deterministic logic, and testable boundaries.
3. Read [coupling.md](references/coupling.md) for cohesion, dependency direction, interface
   size, and change propagation.
4. Merge overlapping observations into one finding. Prefer the lens that best explains the
   root design problem and mention secondary effects briefly.

## Remain language-agnostic

Evaluate semantics rather than syntax. Infer state, effects, contracts, dependency direction,
and module boundaries using the repository's language, framework, tests, and conventions.

- Treat examples in the references as illustrations, not required syntax.
- Respect idiomatic ownership, error, concurrency, and dependency patterns.
- Do not demand pure functions, dependency injection, interfaces, or immutability where they
  add indirection without reducing change cost.
- When a language or framework is unfamiliar, inspect local usage and toolchain evidence and
  lower confidence instead of applying rules from another ecosystem.

## Validate candidates

Report a candidate only when all of the following hold:

- The evidence is observable in the selected scope and necessary context.
- The design creates a concrete correctness, changeability, testability, or operability cost.
- A plausible improvement reduces that cost without merely moving complexity elsewhere.
- Confidence is at least 80%.

Do not report style preferences, speculative future abstractions, or intentional tradeoffs
without evidence of harm. Mention a tradeoff when the current design is reasonable.

## Report findings

Lead with findings ordered by severity, then provide a short summary. Do not assign an overall
letter grade; severity, confidence, evidence, and impact carry the assessment.

For each finding include:

```markdown
### [high|medium|low] Concise title
- Location: `path:line`
- Lens: simplicity | functional-core | coupling
- Confidence: 80-100%
- Evidence: What the code does and the relevant surrounding context.
- Impact: The concrete failure mode or change cost.
- Recommendation: The smallest design change that addresses the cause.
```

Use **high** for likely correctness, data, security, or systemic architecture failures;
**medium** for material changeability, testability, or operability costs; and **low** for
bounded issues worth addressing. If no qualifying findings exist, say so directly and note
any limits in the reviewed scope.

## Claude Code adapter

Claude Code users may invoke `/decomplect` for a standalone install or
`/decomplect:decomplect` for the plugin, optionally with `--simplicity`, `--fcis`, `--coupling`,
or `--sequential`. Treat a lens flag as selecting only that lens, treat `--sequential` as
disabling parallel workers, and treat remaining arguments as the explicit review scope. Other
agents should follow this file directly.
Files in this package (9)
  • SKILL.md 5 KB
  • .claude-plugin/plugin.json 1 KB
  • agents/coupling-analyzer.md 1 KB
  • agents/fcis-analyzer.md 1 KB
  • agents/openai.yaml 1 KB
  • agents/simplicity-analyzer.md 1 KB
  • references/coupling.md 3 KB
  • references/functional-core.md 3 KB
  • references/simplicity.md 2 KB

Versions

The database has no other skills named decomplect.

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

  • 100hickey
    Structural simplicity review based on Rich Hickey's "Simple Made Easy" framework. Trigger when: - Reviewing code for complected concerns, analyzing coupling, or simplifying code architecture. - Prompt contains: /hickey, simple made easy, complect, decouple, compose.
  • 100unslopify
    Review code for weak type or data contracts, mixed responsibilities, hidden failures, workaround-driven error handling, and duplicated knowledge. Use for tactical code-quality review, pull-request review, pre-commit cleanup, refactoring assessment, or requests about type…
  • 100architecture-review
    Review codebase architecture for SOLID violations, dependency health, module boundaries, and structural issues. Use when assessing whole-system structure or coupling. For single-module depth use /deepening-review; for a concrete refactor plan use /refactoring-guide.
  • 100architecture-paradigm-functional-core
    Applies Functional Core, Imperative Shell to isolate logic from side effects. Use when business logic is entangled with I/O or unit tests are slow and brittle.
  • 100code-quality-reviewer
    Reviews code for maintainability: clarity, cohesion, coupling, complexity, duplication, naming, SOLID violations and testability, citing concrete locations and proposing proportionate improvements. Use for code review and before refactoring.
  • 100clean-architecture
    Review code and provide design guidance based on Clean Architecture principles. Checks dependency rule, layer separation, crossing boundaries, and SOLID principles. Use when asked to review architecture, check dependencies, or design with clean architecture principles.

Feedback and reports

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