nixos-config/AI/commands/elegance.md

description	argument-hint	disable-model-invocation
Iteratively simplify & beautify code — research elegance, apply, verify, repeat	<tech> [iterations=3]	true

Elegance Command

Iteratively study and apply elegant coding patterns to the codebase for $0. Each iteration: understand the code, research what simple & elegant code looks like, apply learnings, verify with CI.

Run for $1 iterations (default: 3). The value can be a number (e.g., 3) or a duration (e.g., 2h).

Workflow

0. Determine Scope

• Before starting, use the AskUserQuestion tool to ask: should this operate on the whole codebase or only on changes in the current branch/PR?
• If scoped to current branch/PR, use git diff main...HEAD (or the appropriate base branch) to identify changed files and limit all subsequent steps to those files only.

For each iteration (1 to N):

1. Understand the Codebase

• Read through the relevant source files for $0.
• Note patterns, repetition, unnecessary complexity, non-idiomatic code.

2. Research Elegant Patterns

• Use WebSearch/WebFetch to research what simple, elegant (yet readable!) $0 code looks like.
• Look for idiomatic patterns, standard simplifications, and community best practices.
• Focus on: simplicity, readability, removing unnecessary abstraction, leveraging language features.

3. Apply Learnings

• Refactor the codebase based on what you learned.
• This can include: edits, code reorganization, or even rewrites where simplicity demands it.
• Prefer fewer lines, clearer intent, and idiomatic style.
• Don't add unnecessary abstractions — remove them.

4. Verify

• Run local CI to check your edits: nix run github:juspay/vira -- ci -b
• If CI fails, fix the issues before proceeding to the next iteration.

5. Log Progress

• Briefly note what changed in this iteration and why.

After all iterations:

• Do not git commit. Leave all changes in the working directory for the user to review.
• Present a summary of what changed across all iterations.

Principles

• Simple over clever: Elegant code is simple code.
• Readable over terse: Brevity is good, but not at the cost of clarity.
• Well-commented: Add comments where code isn't self-explanatory. An unsuspecting third-party programmer should be able to understand every non-obvious decision. Don't comment the obvious — comment the why.
• Idiomatic over generic: Use the language's strengths. Write TypeScript like TypeScript, not like Java.
• Each iteration builds on the last: Don't undo previous improvements. Deepen them.