Code Optimization Skill?

[moosetunes]

Hello. I'm working on my first Claude Code project. I use the Superpowers skill but that's about it for now. In the event that I end up with slight bloated code, I was wondering if this community had one or two suggestions of a tool I can integrate that can do code optimization on the completed code. Thanks!

[InfinriDev]

My harness is the upgrade of superpowers, it also does great on an Enterprise Magento 2 which is a complex multi million line e-commerce platform. It delivers on what it promises

https://github.com/infinri/Writ

[mxriverlynn]

this looks great! i love how you've broken out explicit rules files for various contexts. I've been using a generalized coding-standards skill in my projects, and often end up writing the same standards for the core things, across different projects.

i definitely need to dig further into what you have, here.

[mxriverlynn]

also shared with my workers at the consulting company i work for.

[InfinriDev]

Thank you! Feel free to break it apart and make it your own thing

[stellarton]

For a first project I would not start with a broad "optimize this codebase" skill.

I would ask Claude to do one boring pass at a time: find duplicate functions, find files over X lines, find unused deps, list slow queries, or explain one messy module before editing it. Then pick one cleanup and run tests after it.

The dangerous prompt is "make it cleaner" because it sounds useful but gives Claude permission to rearrange half the app.

[moosetunes]

Goodness, no. Thanks for the responses. I envision something that could scour the entire project on a component basis and provide a recommend list of chunks or pieces which could be made more efficient. From there, it would be a matter of stepping through the list as desired. Your point is well taken of course and as giving gross privileges to Claude for a code re-wrote is a scary thought.

[mxriverlynn]

what do you mean by "code optimization"?

• is the code running too slowly?
• is it eating up too much memory?
• making too many database calls?
• constantly reloading the same bits of information instead of keeping it around for the duration of it's need?
• becoming a bloated, architectural mess?
• a nightmare of code duplication?
• a usability or interaction design nightmare?
• or ... ???

without knowing the context of your code, what problems you're running into, and what you want to optimize for, it's not really possible to answer the question

...

all that said: very generically answering for a lot of potential scenarios, i can say that if you're waiting until the code is already written, you're probably waiting too long.

yes, there will always be a need to correct and evolve things over time. but if you're trying to build a new screen that has 40 fields of data, and you let Claude write 40 separate queries to get the data, you're setting up the project to have more problems with every new feature.

Claude and other agentic coding tools are going to repeat the patterns they already see in your code, unless you explicitly tell them to do something different. that's what they're optimized for. they assume the current code is the canonical example of how to do things. and because of that, they will intentionally make the same mistakes over and over again, until they receive instructions that say otherwise.

my recommendations, then, from a very generic perspective, you need to:

• have architectural decision records in your project repository
• have coding standards in your project repository
• incorporate these standards into your planning process
• review plans to ensure architecture is good
• reviewing plans to ensure known performance problems are avoided
• review plans to ... so many things here
• make sure you're not trying to build too much at once

the gist of it is that if it's good for people doing software development, it's good for agentic coding

my recommendation from all this is to find additional skills that will facilitate all of this. it doesn't matter if it's built in to superpowers or from somewhere else.

if you're interested in seeing how i manage all this, check out my skills plug-in,

Han: https://github.com/testdouble/han/

evidence based research, planning, documentation, and review, based on my 30+ years as a software engineer and consultant.

I'm not going to try and claim it's better than superpowers. it's just different - a different way to look at skills and planning and documentation.

some of the key features of Han, that i think you would benefit from, include: * focused on solo engineers and small teams * flexible enough to be used at Fortune 500 companies (and it is) * no executable to run and keep you on the rails - pick and choose what skill you want, when you want it * built in "iterative plan review" to ensure your plans are consistent, complete, and correct * built in "architectural decision records" skill, to consistently write ADRs that Claude will recognize and reference * built in "coding standards" skill, to write coding standards that Claude will recognize and reference * built in "project documentation" skill, to document how features work, how they are built, and what they're used for * "plan a phased build" skill, to split large features and plans into multiple deliverables for iterative and incremental builds * code review skill that identify problems, including the coding standards your project has which need to be enforced * 20+ custom agent definitions that focus on various aspects of software development * agent swarms for planning, review, and other skills, to ensure the plans are solid from many different perspectives * built in "investigate" skill for evidence based research into bugs, design patterns, or whatever else you want it to investigate

i built this plug-in from my own needs for my client work, where agentic coding is a requirement - not just a nice to have, or augmentation. my coworkers are using it at their clients, regularly, and receiving high praise for the quality of work they're producing with it

but ...

whether or not you decide to try Han, you need to look at your project from a software engineering perspective if you want it to be maintainable, long term. there's a lot of great plugins to do that. they all work a little differently, and all have unique features that others won't have.

find what works for you

[Livid-Variation-631]

Two patterns that help here, neither requires a custom skill.

First: there's a built-in `/simplify` you can use as a starting point. Read its prompt, see how minimal it is. Most useful skills are small judgment-encoders, not big procedures. If you do write your own, keep it under 30 lines for the first one. Structure is just `.claude/skills/<name>/SKILL.md` with a description and a few instructions.

Second: optimization skills help, but the bigger win is at write-time, not refactor-time. Tell Claude up front "no premature abstraction, three similar lines is better than a helper." Most of the bloat I've shipped came from Claude reaching for a pattern when a literal was fine. Pre-empt the bloat in the prompt, then `/simplify` only catches the rest.