Five Slightly Unhinged Claude Code Tricks (That Quietly Make You Twice as Dangerous)
Or: how to stop “vibe coding” from turning into “final_final2_really.py” archaeology.
Let’s be honest. Most advice about coding agents is either:
“Just prompt better.” (Brilliant. Like telling someone to “just be taller.”)
“Build a framework.” (Yes, sure, let me spend three weeks building scaffolding for a tool designed to eliminate scaffolding.)
What actually moved the needle for me wasn’t a new model. It was treating Claude Code like a system you can instrument, not a chat you beg.
So here are five advanced tricks I use constantly. They’re boring in the same way seatbelts are boring. Which is to say: you only appreciate them after the first time everything catches fire.
And then I’ll give you a tiny “vibe-coding constitution” plus one ridiculous repo that accidentally isn’t ridiculous at all.
The Meta-Rule: Build guardrails that write themselves
If you remember nothing else, remember this:
The best prompt is the one you never have to type again.
Your real job isn’t “asking the agent nicely.” It’s building a loop where it automatically asks you the right questions, trims your nonsense, and improves the workflow after each run.
That’s what these five are.
1) Self-improvement via “injection” (the 8-tool-call tax)
Agents fail in predictable ways. The funniest one is this:
They’ll happily make 12 tool calls to do something you could have done with one skill… but nobody tells them that, so they keep doing it forever.
The fix is gloriously petty: a hook that nags Claude only when it’s earned the nagging.
What it does:
If Claude makes 8+ tool calls, it appends one single-sentence optimization hint to the prompt—something like:
“This should be a reusable skill.”
“This belongs in memory.”
“This workflow needs a shortcut.”
Why it works:
Because it triggers only after complexity appears, not when you’re still exploring. You’re basically training your environment to notice, “We’re doing that thing again.”
Drop-in prompt (as you wrote it):
“Create a UserPromptSubmit hook (global settings). Script echoes: If 8+ tool calls, append one optimization hint (reusable skill, memory pattern, or workflow fix). One sentence. Skip if exploratory.”
This is the closest thing to “the agent learns” that actually matters day-to-day.
2) Skills audit (a.k.a. “why do I have 19 different hammers?”)
Skills tend to multiply like rabbits. You add one tiny helper, then another, then you forget what any of them do, and suddenly your “toolbox” is a landfill.
So: build a skill that inventories your skills. Not philosophically. Literally.
What it does:
Lists all installed skills (project + global)
Shows line counts
Asks what to review for:
conciseness
overlapping scope
clarity
token efficiency
Why line counts matter:
Because skills rot the way code rots. The day you see a “simple helper” is 420 lines long, you stop trusting your own past self.
Drop-in prompt:
“Create a skill that lists all my installed skills (project & global level) with their line counts. Then ask the user which to review for improvement opportunities (conciseness, clarity, overlapping scopes, token efficiency).”
It’s basically ls -lah for your agent brain.
3) CLAUDE.md audit (your instruction pile is lying to you)
Most people treat CLAUDE.md like sacred scripture.
It isn’t. It’s more like a fridge full of leftovers: technically edible, but you’re going to regret the smell when you open it.
So build a skill that reads all your CLAUDE files and flags:
redundant instructions
verbose phrasing
content that should move into memory instead of bloating the prompt forever
Why this matters:
Because “more instructions” feels like control, but it’s often just context poisoning. You don’t get better behavior—you get a slower, more confused agent that’s busy obeying outdated rules.
Drop-in prompt:
“Create a skill that reads all CLAUDE .md files and checks for: redundant instructions, verbose phrasing, and content that could move to memory. Present findings and ask if the user wants to implement them.”
This is maintenance. Like brushing your teeth. Dull. Non-negotiable. Saves you from pain.
4) Reflection skill (turning every mess into reusable leverage)
Here’s what separates “people who use agents” from “people who get compounding returns”:
They don’t just finish tasks.
They extract patterns from tasks.
So you want a reflection skill that reviews the current conversation and pulls out:
what worked
what broke
what you kept repeating
what should become a new skill
what should be written into memory
what should be simplified
…and then asks what to implement.
Drop-in prompt:
“Create a skill that reviews the current conversation, analyzes tasks, errors, and user feedback, and extracts opportunities for learning, skill creation, and skill improvement; then, presents the findings to the user and asks what to implement or write to memory.”
This is the “weekly review” for your AI workflow. Except it takes 30 seconds and doesn’t involve guilt.
5) Conditional prompt linter (saving you from yourself at 2 a.m.)
There’s a moment in every long session where you type a prompt that is:
183 words
11 clauses
0 clear outcomes
and a hidden plea for emotional support
So build a hook that checks word count and—if >50 words—adds a small note:
“Is the desired outcome actually clear?”
Drop-in prompt:
“Create a UserPromptSubmit hook in global settings. The script counts words and, if >50, echoes a note asking Claude to check if the desired outcome is clear. The output gets appended to the prompt.”
It’s not about being shorter.
It’s about being legible. Agents can’t read your mind. And neither can your future self.
The Seven Laws of Vibe Coding (that are annoyingly accurate)
Let’s codify the chaos:
Any error can be healed by adding the word “carefully”.
backup_old/ is not trash. It’s an evacuation plan.
Always say “quick prototype” even if it’s hour three and the repo contains final_final2_really.py.
Reading the error is optional. What matters is that it disappears after restart.
Vibe coding has two modes: “doesn’t work, don’t know why” and “works, don’t know why.”
If you want to understand why it works, congratulations: you’ve entered adulthood.
When everything collapses, say: “It’s an aesthetic choice.”
If this upset you, it’s because it’s true.
Bonus: “HumanCompiler” — the joke that accidentally points at the future
You also dropped this gem:
A tool that interviews an employee through structured phases, reads Slack/Notion/Gmail artifacts, extracts tacit knowledge, patterns, and “how I do my job”… then compiles it into a Claude Marketplace skill you can load in one click.
That’s HumanCompiler.
Yes, it’s framed as a joke.
But it’s the kind of joke that becomes a product the moment one manager says:
“Wait. Can I make a digital version of our best operator so we stop re-learning the same things every quarter?”
Because the real bottleneck in companies isn’t models. It’s institutional memory.
And “compiling a person” into skills is just an extreme version of what every good team tries to do with playbooks—only this one runs at machine speed.
Practical setup order (so you don’t build a cathedral before you have a door)
If you want this to actually work without turning into a weekend project:
Install the prompt linter hook (cheap, immediate value).
Add the 8-tool-call optimization injection (starts compounding).
Run the CLAUDE.md audit (remove junk early).
Run the skills audit (merge duplicates, cut fat).
Add reflection last (once you have enough activity to reflect on).
The actual point
Claude Code isn’t “a thing that writes code.”
It’s a factory.
And right now most people are using it like a vending machine.
These five tricks are how you turn it into a system that:
improves itself
stays readable
doesn’t drown in instructions
keeps the useful parts
and gently prevents you from doing something stupid with confidence
Which is, frankly, the highest form of intelligence available in 2026.
Your turn
If you want a fun follow-up post, collect “field reports”:
What’s the best hook you’ve written?
What skill saved you the most tokens?
What’s your most embarrassing final_final_REAL.py moment?
Because the only thing better than vibe coding…
…is realizing everyone else is just as guilty.