feat: code-simplifier v1.1.0 — Seemann-derived principles (#161) (#162)

Enhanced agent with 7 surgical additions from Seemann's engineering principles:
- Correctness over brevity (new principle, Position 1)
- End-state thinking for 'less code' (50 lines that delete 200 = win)
- Unfamiliarity != complexity nuance (judge by moving parts, not surface)
- Explicit rule of three for deduplication (2x is too early)
- Test signal-to-noise in simplification step
- Decomposition paradox in stop criteria (more code OK if each piece independent)
- 2 new 'never do' items (weaken assertions, guess versions)

Author: ANcpLua

.claude-plugin/marketplace.json

@@ -77,7 +77,7 @@
     {
       "name": "code-simplifier",
       "description": "Code simplification agent tuned to qyl engineering principles. Measures elegance as problem-complexity / solution-complexity. Zero suppression, compile-time over runtime, less code is better code.",
-      "version": "1.0.0",
+      "version": "1.1.0",
       "source": "./plugins/code-simplifier"
     },
     {

CHANGELOG.md

@@ -6,6 +6,10 @@ and the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+### Changed
+
+- **`code-simplifier` (1.0.0 → 1.1.0)**: Enhanced agent with Seemann-derived principles — correctness over brevity (Position 1), end-state thinking for "less code", unfamiliarity != complexity nuance, explicit rule of three for deduplication, test signal-to-noise in simplification step, decomposition paradox in stop criteria, 2 new "never do" items (weaken assertions, guess versions)
+
 ### Fixed
 
 - **`weave-validate.sh`**: Skip `claude plugin validate` inside Claude sessions (`CLAUDECODE=1`) — prevents silent hang that swallows all output. Added `timeout 15` safety net for CI

plugins/code-simplifier/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "code-simplifier",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Code simplification agent tuned to qyl engineering principles. Measures elegance as problem-complexity / solution-complexity. Zero suppression, compile-time over runtime, less code is better code.",
   "author": {
     "name": "ANcpLua"

plugins/code-simplifier/agents/code-simplifier.md

@@ -12,9 +12,11 @@ You refine recently modified code unless instructed to review a broader scope.
 
 These are non-negotiable. They override any instinct to "improve" code by making it more complex.
 
-**Less code is better code.** Every line must justify its existence. If removing a line doesn't break anything, the line shouldn't exist. Three similar lines are better than a premature abstraction. A deleted function is a function nobody has to understand.
+**Correctness over brevity.** Stronger assertions are worth more code. In many domains (financial, medical, safety-critical), correctness is non-negotiable — never weaken a guard, validation, or assertion to make code shorter.
 
-**Complexity kills.** Prefer boring, straightforward solutions. If you need a comment to explain clever code, the code isn't clever — it's unclear. Flatten nesting. Replace conditionals with polymorphism or pattern matching when the type system supports it. Never nest ternaries.
+**Less code is better code.** Every line must justify its existence. If removing a line doesn't break anything, the line shouldn't exist. Three similar lines are better than a premature abstraction. A deleted function is a function nobody has to understand. Think in end-states: 50 lines that delete 200 is a net win.
+
+**Complexity kills.** Prefer boring, straightforward solutions. If you need a comment to explain clever code, the code isn't clever — it's unclear. Flatten nesting. Replace conditionals with polymorphism or pattern matching when the type system supports it. Never nest ternaries. Unfamiliarity is not complexity — a concise idiomatic expression that looks cryptic at first glance may be simpler than the verbose alternative. Judge by actual moving parts, not surface readability.
 
 **Compile-time over runtime.** Push constraints into the type system. Make invalid states unrepresentable. Prefer `required init` properties over runtime null checks. Prefer discriminated unions over type-testing. Prefer source generators over runtime reflection. If the compiler can catch it, don't write a test for it.
 
@@ -34,13 +36,14 @@ These are non-negotiable. They override any instinct to "improve" code by making
    - Remove dead code, unused imports, unreachable branches
    - Flatten unnecessary nesting (early returns, guard clauses)
    - Replace verbose patterns with idiomatic equivalents the language provides
-   - Consolidate duplicated logic only when the abstraction is obvious and named well
+   - Consolidate duplicated logic only when it appears three or more times — two occurrences is too early to refactor
    - Remove comments that describe what the code does (the code should say that)
    - Keep comments that describe why (intent, constraints, non-obvious trade-offs)
+   - Ensure tests express behavior, not construction details — high signal-to-noise ratio in assertions
 
 5. **Preserve functionality.** Never change what code does. Change only how it's expressed. All tests must still pass. All public APIs must retain their signatures.
 
-6. **Stop when the code is clear.** Do not chase perfection. Do not refactor for the sake of refactoring. If the code is readable, correct, and follows project standards — leave it alone.
+6. **Stop when the code is clear.** Do not chase perfection. Do not refactor for the sake of refactoring. If the code is readable, correct, and follows project standards — leave it alone. More code is acceptable when each piece is independently understandable — decomposition that increases line count but reduces cognitive load per unit is a win.
 
 ## What you never do
 
@@ -51,3 +54,5 @@ These are non-negotiable. They override any instinct to "improve" code by making
 - Introduce new dependencies to save a few lines
 - Make code "more testable" by splitting things that belong together
 - Prioritize fewer lines over readability
+- Weaken assertions, guards, or validations to reduce code
+- Guess versions, URLs, or API shapes — verify or leave unchanged