Skip to content
Skills Library
Programming · Building & coding

code-simplification-edho-ferdian

/code-simplification-edho-ferdian

Rewrite code for clarity without changing behaviour: extract long functions, flatten nesting, merge duplication, remove over-engineering, gated on passing tests. Load it even for one small function. Use for "sederhanakan kode ini", "nesting-nya kebanyakan", "refactor biar lebih rapi", "reduce complexity", "ini over-engineered".

Repository
eef ↗
Licence
MIT
Last repository change
28.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 28.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

Rewrite code for clarity without changing behaviour: extract long functions, flatten nesting, merge duplication, remove over-engineering, gated on passing tests. Load it even for one small function. Use for "sederhanakan kode ini", "nesting-nya kebanyakan", "refactor biar lebih rapi", "reduce complexity", "ini over-engineered".

Triggers from the description

sederhanakan kode ininesting-nya kebanyakanrefactor biar lebih rapireduce complexityini over-engineered
Original author description

Rewrite code for clarity without changing behaviour: extract long functions, flatten nesting, merge duplication, remove over-engineering, gated on passing tests. Load it even for one small function. Use for "sederhanakan kode ini", "nesting-nya kebanyakan", "refactor biar lebih rapi", "reduce complexity", "ini over-engineered".

How it works

  1. Scope — boundary with three neighboring skills
  2. The one invariant that governs everything here
  3. Surgical changes (carve-out — see skill-authoring-edho-ferdian's canonical contract)
  4. Language routing (fixed — see skill-authoring-edho-ferdian's canonical contract)
  5. Workflow
  6. Phase 0 — Safety net check (gate)
  7. Phase 1 — Identify simplification targets
  8. Phase 2 — Apply one pattern at a time, verify after each
  9. Phase 3 — Report
  10. Global rules
Original SKILL.md headings · 200 lines, 1,490 words
SKILL.md preview
---
name: code-simplification-edho-ferdian
description: >-
  Rewrite code for clarity without changing behaviour: extract long
  functions, flatten nesting, merge duplication, remove over-engineering,
  gated on passing tests. Load it even for one small function. Use for
  "sederhanakan kode ini", "nesting-nya kebanyakan", "refactor biar lebih
  rapi", "reduce complexity", "ini over-engineered".
metadata:
  last_reviewed: "2026-10-08"
---

# Code Simplification — Edho Ferdian Mode

You are a refactoring specialist whose only goal is making already-working
code easier to read — never making it do something different. Every change
in this skill preserves behavior; if you're not confident a change preserves
behavior, you don't make it without the safety net in Phase 0 first.

## Scope — boundary with three neighboring skills

This ecosystem already has three skills that touch nearby ground. Each has a
different moment and a different relationship to the code:

| Skill | Moment | Touches code? |
|---|---|---|
| `code-review-edho-ferdian` | Finds a complexity/duplication/over-abstraction issue and reports it (CQ-01, CQ-04, CQ-04b in `review-checklist.md`) | No — read-only, one line in a findings report |
| **This skill** | Given code that already works, makes it clearer | Yes — rewrites, behavior-preserving only |
| `dead-code-cleanup-edho-ferdian` | Code that is genuinely never executed or imported | Yes — deletes it |
| `build-fix-edho-ferdian` | Code that fails to build, compile, or start | Yes — minimal surgical fix, and its own contract explicitly says **never refactor** while fixing |

If the user just wants to know what's wrong, point them at
`code-review-edho-ferdian`. If they want unreferenced code gone, point them
at `dead-code-cleanup-edho-ferdian`. If the code doesn't run at all yet, that
is `build-fix-edho-ferdian`'s job first — don't attempt to simplify code you
haven't confirmed builds and passes its existing tests, because you have no
way to tell whether your rewrite actually preserved behavior.

## The one invariant that governs everything here

**Behavior-preserving only.** Never bundle a simplification pass with a
feature change, a bug fix, or a build fix — those are different units of
work with different review needs, and mixing them turns an already-hard-to-
review diff (a rewrite) into one nobody can review with confidence. If a bug
surfaces while simplifying, stop, report it, and let the user decide whether
to fix it now (as its own separate change) or after.

## Surgical changes (carve-out — see skill-authoring-edho-ferdian's canonical contract)

This skill is a deliberate, stated exception to the default in
`skill-authoring-edho-ferdian` §10 ("touch only what the user's current
instruction requires"), not an adopter of it: this skill's entire purpose is
non-surgical rewriting — restructuring already-working, adjacent code for
clarity is the job, not a side effect to avoid. The constraint that keeps
this from becoming unbounded scope creep isn't §10's line-by-line rule but
this skill's own: **behavior-preserving only**, one pattern applied and
verified at a time (Phase 2), and **one simplification pass = one
isolatable, revertable unit of work** never mixed with an unrelated feature
change or bug fix (Global rules 1 and 5). Full contract:
`skill-authoring-edho-ferdian` §10.

## Language routing (fixed — see skill-authoring-edho-ferdian's canonical contract)

Narration to the user in Bahasa Indonesia; code, diffs, and commit messages
in English. Full contract: `skill-authoring-edho-ferdian` §7.

## Workflow

```
Phase 0  Safety net check (gate)              — run/confirm tests before touching anything
Phase 1  Identify simplification targets      — both under- and over-factored code
Phase 2  Apply one pattern at a time, verify   — never batch unverified rewrites
Phase 3  Report
```

---

## Phase 0 — Safety net check (gate)

Before touching anything:

1. **Is there a runnable test suite covering the code being touched right
   now?** If yes, run it once to capture a baseline before any rewrite.
2. **If no coverage exists for this code**, stop and choose explicitly with
   the user rather than proceeding on faith:
   - Write characterization tests first — tests that lock in the code's
     *current* observable behavior, not its intended behavior — before any
     rewrite. Consult `test-authoring-edho-ferdian` for how to write these.
   - Or, if the user explicitly accepts the risk, limit the pass to the
     smallest, most mechanically-obvious changes only (pure renames,
     extracting a block without reordering or changing conditions) — no
     restructuring of control flow or abstraction boundaries without a net.
3. **Confirm the code builds and runs at all** before simplifying it — if it
   doesn't, that's `build-fix-edho-ferdian`'s job first (see Scope above).

This mirrors the same reasoning `dead-code-cleanup-edho-ferdian`'s Phase 0
already applies to deletion ("cleanup without a runnable test suite is
materially riskier") — applied here to rewriting instead of removing.

---

## Phase 1 — Identify simplification targets

Simplification runs in **two directions**, and missing either one produces a
lopsided result:

1. **Under-factored** — a function has grown past a readable size or nesting
   depth, or the same logic is duplicated across call sites. This
   ecosystem's exact size/nesting thresholds already live in
   `code-review-edho-ferdian/references/baseline-conventions.md` (function
   length, deep nesting past 3–4 levels) and `review-checklist.md` CQ-04
   (DRY) — don't restate the numbers here, read them there.
2. **Over-factored** — an abstraction, interface, or config flag exists "just
   in case," with only one real caller; a wrapper function that adds no
   behavior of its own; an indirection layer nobody actually needs yet. This
   is CQ-04b's over-abstraction case, viewed from the opposite direction. A
   refactoring skill that only knows how to extract-and-abstract will, if
   applied enough times, make code *more* complex — naming this failure mode
   explicitly is what keeps this skill from doing that.

**Language-specific shape matters.** Whether the idiomatic simplification of
a given hotspot is a list comprehension, an early return, a match expression,
or a higher-order function depends on the stack. Consult
`language-code-review-edho-ferdian`'s per-language references for the
correct idiom rather than applying one language's style universally.

**Find hotspots systematically, don't just eyeball the file.** Use whatever
complexity tooling the stack has: ESLint `complexity`/`max-depth` rules
(JS/TS), `radon cc` (Python), `gocyclo` (Go), `cargo clippy`'s complexity
lints (Rust) — same stack-detection-from-manifest pattern the rest of this
ecosystem's skills use. If nothing applies, fall back to a manual read,
prioritized by whatever the user already flagged as hard to read.

---

## Phase 2 — Apply one pattern at a time, verify after each

**Hard rule: never batch multiple simplification patterns into one
unverified pass.** Apply one, run the test suite (or the characterization
tests from Phase 0), confirm green, then move to the next — the same
"verify after each category, not just at the end" discipline
`dead-code-cleanup-edho-ferdian`'s Phase 3 already applies to deletion.

Common patterns, applied only where they genuinely reduce reading effort:

- **Extract function/method** — a block doing one identifiable sub-task gets
  its own well-named function.
- **Guard clause / early return** — flattens nested `if`s into a sequence of
  early exits instead of a pyramid.
- **Consolidate duplicate branches** — near-identical `if`/`switch` arms
  merged into one, parameterized by what actually differs.
- **Replace a loop with an idiomatic higher-order call** (`map`/`filter`/
  `reduce` or the stack's equivalent) — only when it is *more* readable in
  that language's idiom, not simplification-by-fashion.
- **Collapse unnecessary indirection** — a wrapper, adapter, or interface
  with exactly one implementation and no near-term second one gets inlined.
- **Replace conditional with polymorphism/strategy** — apply only when 3+
  call sites genuinely diverge the same way; otherwise this pattern *creates*
  the over-abstraction Phase 1 exists to catch, not reduces it.

**Hard rule: one simplification pass = one isolatable, revertable unit of
work.** Never mixed with unrelated changes, same as
`dead-code-cleanup-edho-ferdian`'s commit discipline.

---

## Phase 3 — Report

After the last pattern, report to the user (Bahasa Indonesia for narrative,
English for identifiers/paths):

- What changed per hotspot — before/after nesting depth or function length,
  duplication removed, abstraction layers collapsed.
- Test status after each individual change (pass/fail), and final status.
- What was flagged as a candidate but deliberately left alone, with the
  reasoning (e.g. "this abstraction has 3 real divergent call sites — kept,
  not over-abstraction").
- An explicit reminder of what Phase 0's safety net did and did not cover,
  so the user knows which parts of the diff are test-verified versus
  mechanically-obvious-only.

## Global rules

1. **Behavior-preserving only.** No functional changes bundled in — ever.
2. **No safety net → stop or downgrade to trivial-only changes.** Never
   silently proceed on faith that a rewrite preserved behavior.
3. **Simplification runs both directions** — extracting from under-factored
   code AND removing over-factored abstraction both count; a skill that only
   does one is doing half the job.
4. **Verify after every single pattern application**, not just at the end.
5. **One simplification pass = one isolatable, revertable unit of work.**
   Never mixed with unrelated changes.
6. **Defer to specialists at the edges**: `language-code-review-edho-ferdian`
   for idiom-correct shape, `test-authoring-edho-ferdian` when a
   characterization test is needed first, `build-fix-edho-ferdian` when the
   code doesn't run yet, `dead-code-cleanup-edho-ferdian` when it's not run
   at all.
7. **Language routing** as defined above.

## Provenance

Native to this ecosystem — not ported from any external source (checked
against `project-memory/06-ecc-286-item-ledger.md`, this project's full
upstream-porting survey: no matching item) and not a port of any generic
marketplace "code-simplification" skill; written fresh to fit this
ecosystem's own domain split against `code-review-edho-ferdian`
(CQ-01/CQ-04/CQ-04b), `dead-code-cleanup-edho-ferdian`, and
`build-fix-edho-ferdian`'s explicit "never refactor while fixing" rule.
Built 2026-09-12 per direct user request, after confirming via grep that no
equivalent skill or agent already existed in `skills/` or `agents/`.

Versions

The database has no other skills named code-simplification-edho-ferdian.

Identical content appears in 4 other GitHub folders. We show one copy with the highest score.

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

  • 90language-code-review-edho-ferdian
    Stack-specific review lenses on top of code-review: idioms, framework misconfigurations, ORM query traps, performance and test conventions across ~20 stacks. Load it for any review of code in a named framework, even one or two files. Use for "review kode Go/Python/React ini",…
  • 100code-simplification
    Use when code works but is harder to read, maintain, or extend than it should be — after a feature lands, when review flags complexity, or when you hit deep nesting, long functions, high cyclomatic complexity, functions too tangled to test, two functions that do nearly the same…
  • 100spec-mining-edho-ferdian
    Extract behavioural specs from a codebase with none: WHEN/THEN requirements and invariants, each anchored to the code that enforces it, unclear behaviour recorded as uncertainty. Use for "ekstrak spec", "buat spec dari kode", "reverse-engineer the spec", "repo ini tidak ada…
  • 100code-simplification
    Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity. Use when asked to simplify, clean…
  • 100spine-simplify
    Post-feature clarity pass — collapse needless indirection, delete dead code, flatten nesting, surface duplicated logic, fix altitude mismatches. Behavior-preserving only. Use when asked to "simplify this", "clean up this code", "reduce complexity", "this feels over-engineered",…
  • 100refactor-module
    Use when a ticket asks to restructure code without changing what it does — extract a function, split a file, rename for clarity, reduce duplication — with behaviour preserved. Invoke for "refactor X", "clean up the Y module", or "extract Z" where no behaviour change is intended.

Feedback and reports

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