Claude writes good code. It lacks method, budget and taste

With nothing added, Claude writes code that works. What it does not come with are three different things: a working method, visibility into what you are spending, and design judgement.

There are three free tools that solve one each, and I would recommend all three. They install by typing two lines, they cost nothing, and on the right project any one of them saves you real work. You do not have to use all three: one that happens to match what you are doing is already worth it.

This article explains what each one does, how to install it, and — the part that almost never gets told — what it costs you to have them switched on.

First: what a skill is, and what a plugin is

If you already know this, skip the section. If you do not, none of the rest will make sense.

A skill is a folder with instructions written in plain text. Claude reads it on its own when it notices that the task you asked for is one that folder covers. It is not a program that runs: it is guidance that enters the conversation at the moment it is needed.

A plugin packages several skills together, plus commands you can type yourself with a slash: /something.

A marketplace is a list of plugins you can install from. Anthropic maintains an official one, and anyone can publish their own from a GitHub repository.

The three tools here are plugins, all three are MIT licensed, and all three install by typing two lines.

1. Superpowers — the method

The problem it solves: by default, Claude starts writing code straight away. You ask for something half defined and it hands back an implementation of what it understood, which is not always what you wanted.

Superpowers changes that. Before writing a line, it stops and asks what you are actually trying to achieve. Out of that conversation it builds a specification, shows it to you in chunks short enough to actually read, and only moves on to the plan once you approve.

It writes the plan as tasks of two to five minutes each, with exact file paths. Then it executes them by dispatching one subagent per task, with review in two stages: first whether it meets the spec, then the quality of the code.

There are fourteen skills that activate on their own depending on the moment:

Skill	When it comes in
brainstorming	Before any code, to get the specification out
writing-plans	Once the design is approved
using-git-worktrees	Creates a branch and an isolated workspace
subagent-driven-development	Runs the plan, one subagent per task
test-driven-development	Failing test first, then the code
requesting-code-review	Between tasks, with critical issues blocking progress
systematic-debugging	When something fails and you have to find out why
finishing-a-development-branch	Verifies, offers to merge or discard, cleans up

It installs from Anthropic’s official marketplace:

/plugin install superpowers@claude-plugins-official

Who it is for: anyone who gives it long tasks and wants the result to be reviewable. If your use is short questions and two-line changes, the method will feel heavy.

One fact that helps you decide: it works in more than a dozen tools besides Claude Code — Cursor, Codex, Gemini CLI, Copilot CLI — so what you learn does not go to waste if you switch environments.

2. context-optimizer — the cost

The problem it solves: you have no idea where the money goes.

Every time Claude reads a file, that file enters the conversation and gets paid for. And it keeps getting paid for on every following turn, because the whole conversation is resent each time. A configuration file it looked at once “just in case” is still costing you twenty turns later.

This plugin silently records every read, every edit and every search. From that it builds a profile of how you work and tells you which files you actually used and which were pure waste.

The commands that pay off most:

/cco              # One screen: budget, spend, waste
/cco-overhead     # What each session costs to start, before you type anything
/cco-claudemd     # Reviews your CLAUDE.md and marks what is surplus
/cco-coach        # Grades your prompt and suggests how to improve it
/cco-pack         # Builds the minimum file list for a task

It installs like this:

claude plugin marketplace add egorfedorov/claude-context-optimizer
claude plugin install claude-context-optimizer@cco

One thing worth stating clearly: the project claims that an average session wastes between 30% and 50% of its tokens on files that get read and never used. That is the author’s figure, measured with his own tool, not an independent measurement. The honest way to take it is as a hypothesis you can verify in your own case, which is exactly what the tool lets you do.

Two details that show it is current: it knows the prices of Opus 5, Sonnet 5, Haiku and Fable 5.1 separately — each model costs a different amount and bills caching differently — and it knows that the context cache today lasts an hour and not five minutes, which is what earlier versions assumed.

3. ui-ux-pro-max — the design

The problem it solves: Claude knows how to write CSS, but not what looks good. You ask for a page and out comes something that works and looks like a 2015 template: the colours do not quite go together, the fonts do not match, the spacing is arbitrary.

That happens because designing is not writing code: it is making decisions that depend on accumulated knowledge. This skill hands it that knowledge as a catalogue:

• 79 interface styles it can search by name
• 192 colour palettes
• 74 font pairings, drawn from 1,934 approved Google fonts
• 119 user experience guidelines
• 25 chart types and 22 technology stacks

With that, when you ask for a page, it first generates a complete design system — page pattern, style, palette, fonts, spacing scale — and only then writes the code.

It installs with:

/plugin marketplace add nextlevelbuilder/ui-ux-pro-max-skill
/plugin install ui-ux-pro-max@ui-ux-pro-max-skill

And it activates on its own when you ask for anything interface related. You do not have to invoke it:

Build a landing page for my product

The limit it has: it gives you a starting point far above what Claude reaches on its own, but it is a catalogue of known options. It will not invent a visual identity for you. If what you want is a site that looks like nothing else, this gets you to the high end of average, not to distinctive.

What they cost

Here is the part these projects’ own pages do not mention, and that is worth being clear about before installing all three at once.

Everything you add takes up room in the conversation. A plugin’s instructions, the list of its commands and the descriptions of its skills are loaded into every session, before you type your first word. It is a fixed cost you pay always, whether or not you use that tool that day.

With three plugins installed that floor stops being negligible. And there is something that goes unnoticed: the more of the context is taken up by instructions, the less room is left for your code, which is what actually matters for the model to have in front of it.

The good news is that the second tool measures exactly that:

/cco-overhead

That command audits the fixed floor of every session — system instructions, plugins, agents, your CLAUDE.md — and tells you how much each thing takes up. It is how you decide, with a number, whether the other two are earning their place.

The order I would install them in

context-optimizer first, on its own. Use it for a week as it comes. Without a measurement beforehand, you will have no way of knowing whether what you add later improves anything or makes it worse.

Then whichever solves your real problem. If what you get back is different from what you had in your head, Superpowers. If your screens work but look bad, ui-ux-pro-max. One at a time, measuring with /cco-overhead in between.

All three from day one, no. That is the fastest way to end up with a context full of instructions, without knowing which of the three is serving you and which is only taking up room.