Ultra hacks 2026: finds from 45+ sources across the internet

Module: Professional practice | Time: about 30 min reading + 45 min practice

This lesson was put together in May 2026 from online research: 45+ sources, popular GitHub repositories, Reddit, Hacker News and Anthropic's official documentation. During the October 2026 review, the facts about Claude Code were checked against the official documentation; third-party repositories, courses and articles were not rechecked, so open them and check them yourself before you rely on them.

The gist

In a few months of working with Claude Code, one person picks up tricks that another only learns a year later. This lesson is a distillation of hacks from all over the internet: things that went viral, that collected lots of stars on GitHub, that people discussed on Reddit at 3 a.m.

🎨 Picture this: imagine you read the logbooks of 1,000 pilots who all flew the same plane. Each one found their own tricks. This lesson collects the best of them into one checklist.

Key concepts

• ccforeveryone.com: a course that teaches you INSIDE Claude Code through /start-1-1
• Two Claudes: a parallel work pattern where one writes and the other reviews
• RTK: compressing command output before it goes to the LLM (to save tokens, the units of text AI works in)
• Caveman Mode: a mode with as few words as possible in responses
• The Claude Code source code leak (March 31, 2026): a lesson in how a small packaging mistake can expose proprietary code
• Hooks: events like CwdChanged, FileChanged, PreCompact and PostCompact, which people used to know only from community discussions and which are now official

Theory

Hack #1: A course inside Claude Code

ccforeveryone.com takes an unusual approach to learning: the course runs inside Claude Code itself (as of May 2026; check that it still works):

# In Claude Code, type:
/start-1-1

# Claude becomes your personal tutor
# You learn right in the chat, by doing
# A few hours, aimed at non-technical people
# You need a paid Claude subscription (current plans: the "What's current" page)

🎨 Picture this: it's like learning to swim in the water instead of reading a textbook on the shore. You learn Claude Code right inside Claude Code.

Hack #2: Two Claudes, the architect and the critic

One of the most popular patterns of 2026: you run two Claudes in parallel on the same project using Git worktrees (Claude Code has a --worktree flag for this).

# Terminal 1: the builder Claude
cd /project-worktree-main
claude
# "Write function X"

# Terminal 2: the reviewer Claude (independently!)
cd /project-worktree-review
claude
# "Do a code review of: [paste the code from terminal 1]"

🎨 Picture this: it's how good architecture firms work. One architect designs, and a second one does a safety review independently. Neither knows about the other's work in advance, which is why the review is honest.

Why it works: the second Claude doesn't have the first one's context → it sees the code with fresh eyes → it finds what the first one has "gotten used to not noticing." For a quick review there's also the built-in /code-review command (levels from low to max, plus ultra), but an independent second session is still a useful technique.

Where to use it:

• One Claude writes code → the second does a security review
• One Claude generates content → the second checks it for factual errors
• One Claude designs the architecture → the second plays devil's advocate

Hack #3: Gemini CLI as an assistant

When Claude can't load a large site or you need to process a lot of data in parallel, delegate to Gemini.

# Install
npm install -g @google/gemini-cli

# In Claude Code:
claude
# "Use Gemini CLI to read all the documentation on docs.example.com
#  and give me a short summary of the key API endpoints"

🎨 Picture this: Claude is the lead project manager. Gemini CLI is an intern who gets "go fetch the data" assignments. Claude makes the decisions, Gemini does the heavy parsing work.

A real use case: Claude asks Gemini to read 50 pages of documentation → Gemini returns structured JSON → Claude analyzes it and writes the code.

Hack #4: Session retrospective

At the end of every work session:

"What did you learn in this session that's worth remembering for the future?
 What worked well? What didn't?
 Update CLAUDE.md with these insights."

🎨 Picture this: like a pilot's logbook after a flight. "Today this technique worked for landing in fog. I'll write it down for next time."

Claude updates its own instructions, so the system gets smarter with every session. Today Claude Code can also record lessons from your corrections on its own (auto memory, managed with /memory), but a deliberate retrospective in CLAUDE.md is more reliable.

Hack #5: RTK, compressing command output

RTK is an idea and a family of CLI tools that compress long command output before it goes to Claude, so you spend fewer tokens. The names, authors and installation methods of these utilities change, so check them in the project's repository. Without installing anything, you can get a similar effect with a simple tail or grep on the output.

# Install: follow the instructions in the project's repository (the method depends on the version)

# Instead of:
npm test 2>&1 | claude "what broke here?"

# Use:
npm test 2>&1 | rtk | claude "what broke here?"

# RTK compresses: removes duplicates, formats stack traces,
# keeps only what matters

🎨 Picture this: instead of sending a friend the full recording of the game, you send the highlights. They get the point in 2 minutes instead of 90.

Hack #6: Caveman Mode

Tired of Claude's wordy answers? Turn on Caveman Mode:

# At the start of the session:
"Caveman Mode ON.
Respond only with code and the bare minimum of words.
No explanations unless I ask. No 'sure', 'great', 'here you go'.
Just do it."

🎨 Picture this: the "quiet" mode in a GPS app. You don't need a voice explaining every turn, just an arrow showing where to go.

The opposite: if you need explanations, use "Teacher Mode: explain every step as if to a beginner."

Hack #7: The full list of hooks (not just the basic ones)

The documentation used to describe only the basic hooks. Today there are more official events, including the ones this lesson once called "undocumented." For the full list, see the hooks documentation and the /hooks command:

// .claude/settings.json
{
  "hooks": {
    "PreToolUse": [{"matcher": "Bash", "hooks": [...]}],
    "PostToolUse": [{"matcher": "Write", "hooks": [...]}],
    "Stop": [{"hooks": [...]}],
    "UserPromptSubmit": [{"hooks": [...]}],
    
    // Events added later (check the current list in the documentation):
    "CwdChanged": [{"hooks": [...]}],      // When the working folder changes
    "FileChanged": [{"matcher": "*.py", "hooks": [...]}],  // When a file changes
    "PreCompact": [{"hooks": [...]}],       // Before the context is compressed
    "PostCompact": [{"hooks": [...]}]       // After compression: restore context
  }
}

A killer use case for PostCompact:

#!/bin/bash
# post-compact.sh: runs automatically after /compact
# Restores important context that may have been lost

echo "=== Session after compact ==="
cat STATUS.md  # Project state
cat ACTIVE-TASK.md  # Current task
echo "=== Continue from here ==="

Hack #8: Shorter and sharper without patching the system prompt

Unofficial patches that "trim the fat" from Claude Code's system prompt are popular in the community (for example, in the ykdojo/claude-code-tips repository). These patches break with every update, and the token savings are hard to verify. The official ways to get shorter answers are more reliable:

# 1. Short style rules in the project's CLAUDE.md or your personal CLAUDE.md
#    "No intros or summaries unless asked. When editing, show only the changed lines."

# 2. Add your own instructions to the system prompt at launch
claude --append-system-prompt "Be concise. No preambles."

# 3. Pick an output style through /config

🎨 Picture this: like stripping extra layers of varnish off furniture without taking the chair apart. The wood shows through, and the chair stays in one piece.

Important: unofficial patches are at your own risk and may stop working after an update.

Hack #9: An unusual way to find clients through GitHub

An idea from discussions on Reddit's r/ClaudeCode: look for potential clients by scanning public issues on GitHub. GitHub's terms restrict using people's data for mass outreach, so reply helpfully in the open discussion instead of sending spam:

# Find repositories where people complain in issues
import requests

def find_potential_clients():
    # Search issues by keywords
    query = 'is:issue is:open "automation" "manual process" "takes too long"'
    response = requests.get(
        f'https://api.github.com/search/issues?q={query}&sort=created',
        headers={'Authorization': f'token {GITHUB_TOKEN}'}
    )
    
    for issue in response.json()['items']:
        print(f"Repo: {issue['repository_url']}")
        print(f"Issue: {issue['title']}")
        print(f"Contact: {issue['user']['login']}")
        print("---")

🎨 Picture this: like finding clients in construction, not through ads but by driving through neighborhoods and spotting houses with leaky roofs. GitHub issues are a business's "leaky roofs."

Hack #10: The Claude Code source code leak (March 2026)

On March 31, 2026, Anthropic accidentally published a version of the Claude Code package to npm with a source map file, which made it possible to reconstruct the source code (around half a million lines). The company confirmed the packaging error and said that no customer data, keys or model weights were exposed.

We won't dig into the leaked proprietary code in this lesson, and blog retellings often mix facts with speculation. There are two practical takeaways:

1. For you as a package author: make sure source maps and internal files don't end up in the package you publish (the files field in package.json, .npmignore, and a npm pack --dry-run check before publishing).
2. For your prompts: asking directly is more reliable than counting on hidden modes.

# If you want more accurate answers, add to your prompt:
"Say 'I don't know' when you're not sure. Don't fill gaps with guesses."

# If you want brevity:
"Keep your answers as short as possible, no intros."

Top 3 GitHub repositories worth knowing

Star counts and contents change: open the repository and check that it's still maintained.

A counterpoint: METR research

A METR study (run in the first half of 2025, published in July 2025) found that experienced developers using the AI tools of that time were 19% slower on real tasks in repositories they knew well, even though they themselves believed they were working faster. There were few participants (16 people), and the tools have changed a lot since then, so treat it as a caution, not a verdict.

🎨 Picture this: a new hammer in the hands of an experienced carpenter. He's used to the old one, so at first the new one gets in the way. Later it helps.

Takeaway: Claude Code isn't a magic pill. It takes adjusting to, and at first your speed may go down rather than up. Measure results on your own tasks, not on other people's numbers.

An honest disclaimer for clients: "There's an adjustment period at first. Don't expect a dramatic speedup on day one."

Practice

1. Try Two Claudes: open two terminals, write code in one and review it in the other
2. Caveman Mode: start your next session with "Caveman Mode ON" and feel the difference
3. Retrospective: at the end of today's session, ask Claude to update CLAUDE.md with insights
4. Open awesome-claude-code: spend a little time on github.com/hesreallyhim/awesome-claude-code
5. PostCompact hook: add a hook that reads STATUS.md after /compact

# Testing Caveman Mode
claude
> Caveman Mode ON. Write a function to validate an email address in Python.
# Expected: code only, minimal words

# Testing the retrospective
> What did you learn in this session? Update CLAUDE.md.

Tools and resources

• ccforeveryone.com: a course inside Claude Code, /start-1-1
• Anthropic Academy: the official free course
• awesome-claude-code: a catalog of resources
• claude-code-tips (45): specific tricks
• Ultimate Guide: a large reference
• 50 Tips — Builder.io: practical advice

Key takeaways

"Two Claudes" is one of the strongest patterns of 2026. One writes, the other reviews independently. Code quality goes up and blind spots disappear.

Caveman Mode and Teacher Mode are two opposite ends. Switch between them depending on the task instead of getting stuck in one.

The PostCompact hook is an underrated tool. After /compact, some details get lost. A hook can bring important context back automatically.

The METR research is a reminder: an AI tool doesn't always speed up your work, especially at the start. Measure it on your own tasks and be honest with clients about it.

Next lesson

→ Security in Claude Code: .env, secrets and data protection

Sources: online research from May 2026. Facts about Claude Code were checked against the documentation in October 2026; check third-party resources yourself.