5 Weak Spots of Claude Code and How to Fix Them

Claude Code reads code, edits files and runs commands in the terminal. At those tasks it is very good. But ask it to watch a video or design a nice front end, and the limits show up fast.

I test dozens of tools around Claude Code. The same set of five weak spots keeps coming back: video, design, memory, research and tokens (token - the unit of text a model counts and that you pay for). These are not flaws that break your work with code. They are areas where Claude Code simply has no built-in feature.

The good news: each of these gaps can be patched. Not with theory, but with a concrete tool. For every area I will show what I use day to day. And I will be honest - some tools I have tested in daily work, some are only on my radar, and I will flag that clearly.

The framing was inspired by a Chase AI video about five repos for Claude Code. But this is my own stack - tools I run myself, with my own caveats.

🎬 Video - Claude Code cannot see or make videos

Claude Code cannot watch a video or generate one. By default it gets stuck on the transcript (transcript - a text record of the audio track). And a transcript is not enough when what matters is happening on screen.

Watching: Claude Video

Claude Video is a skill (skill - a ready set of instructions that extends the agent with a new ability) with the /watch command. I paste a URL or file plus a question. The agent pulls captions, extracts frames (frame - a single image from a video) and reads them as images. Before it answers, it has actually seen the video instead of guessing from the title.

I use it for two things. I analyze other people's content faster than playback at 2x, and I pull knowledge that then lands in my notes base. It also works as a transcript grabber for YouTube.

/watch https://youtu.be/dQw4w9WgXcQ co dzieje sie w 30 sekundzie?

The token cost depends mostly on frames, because each one is an image. That is why the skill has four modes, from cheapest to most expensive:

transcript    - captions only, no frames (cheapest)
efficient     - keyframes, up to 50
balanced      - on scene changes, up to 100 (default)
token-burner  - no frame cap (full coverage, pricey)

The efficient mode takes keyframes (keyframe - a frame the video itself marks as a reference point). When a video has no captions, the skill turns speech into text with the whisper model (whisper - a model that converts speech to text), for free through Groq.

Creating: HyperFrames

The opposite direction is generating video. HyperFrames builds video from HTML files - a composition is plain HTML with data-* attributes, no React and no custom language. The "brand" lives in my own CSS styles, so every video comes out consistent with my visual identity rather than generic.

npx skills add heygen-com/hyperframes

It needs Node.js >= 22 and FFmpeg. I already wrote about generating video from code in the piece on Remotion for explainer videos. The difference is simple: HyperFrames is HTML-native and under an Apache 2.0 license (commercial use with no limits), while Remotion ships distributed rendering in the cloud.

🎨 Design - no more generic AI slop

Ask Claude Code for a page and you get exactly what everyone else gets: a hero section on top, rounded cards, a purple gradient. That is AI slop (AI slop - the generic look that instantly gives away a front end generated by a model). The reason is simple: models were trained on the same templates.

I do not patch this with one tool, but with three skills lined up in order: who, system, guard.

1. UX RULER - who and why

UX RULER forces the question "who is this for and what measurable value does it give", before I jump into features. It writes the decisions about audience and need into the repository as product memory (product memory - files in the repo that hold product decisions for the next human or agent). That way the choices are explicit and reusable.

2. UI UX Pro Max - a ready design system

UI UX Pro Max generates a coherent design system (design system - a set of rules for color, typography and components) matched to the project type. A portfolio gets a different logic than a SaaS or a shop. I run it with Tailwind CSS and React as a base that I then refine, which saves prototype time. I covered this tool in more depth in 5 GitHub repos for Claude Code, so I will not repeat it here.

3. Impeccable - the design-language guard

Impeccable is the layer that removes the tell-tale signs of AI: Inter everywhere, purple gradients, cards inside cards, gray text on colored backgrounds. It has a deterministic linter (linter - a tool that checks code or a layout against fixed rules) that runs with no model and no API key:

npx impeccable detect src/

The skill ships 23 commands under /impeccable, among them craft, shape, critique and colorize, plus 27 deterministic rules and an extra model review. This is the thing that keeps a front end from screaming "an AI made me".

Together it forms a line: RULER says who for, Pro Max builds the system, Impeccable guards the language and cuts the AI slop.

🧠 Memory - Claude Code forgets after every session

The end of a session is a reset. Claude Code has no built-in memory that accumulates across conversations. Every time it starts from zero.

A second brain as memory

My approach is a second brain (second brain - a text notes base that the agent reads, updates and searches). The repository is my memory: the agent writes knowledge into it, links notes and answers questions from the whole.

This is a pattern that Andrej Karpathy named LLM Wiki (LLM Wiki - a base that the model itself builds and maintains from your sources). It differs from RAG (RAG - a technique where the model searches raw documents before answering). In RAG nothing accumulates, because the model rediscovers everything each time. In an LLM Wiki the knowledge stays in the files and grows.

The key element is progressive disclosure (progressive disclosure - arranging notes so the agent can find them without cluttering the context window). The context window (context window - how much text the model sees at once) is limited, so a good index matters more than dumping everything into one file.

I built this on Obsidian and Claude Code. The full architecture, 185 notes and three indexes I described in the article on Karpathy's LLM Wiki and in building a second brain in Obsidian. Where the code graph ends and the notes base begins, I lay out in the piece on RAG.

How to build such a base from scratch, I show step by step in the free LLM Wiki course.

NotebookLM-py - a fresh addition

NotebookLM-py puts NotebookLM (NotebookLM - a Google engine where Gemini reads your sources and answers with citations) inside Claude Code. It is an unofficial API, so I use it at my own risk.

uv tool install "notebooklm-py[browser]"
notebooklm login

For now it mostly serves as a second route to YouTube transcripts. I am only starting, so I treat it as an addition, not a foundation.

🔎 Research - the built-in search is shallow

The built-in search in Claude Code works, but only on the surface. What is missing is the middle ground between "shallow" and "a hundred agents and 10 million tokens on deep research" (deep research - a deep, multi-source study of a topic).

Firecrawl - reliable page fetching

When the built-in scraper (scraper - a tool that pulls the content of a page) fails, I reach for Firecrawl. It turns any page into clean markdown or structured JSON, handling JavaScript and pagination.

pip install firecrawl-py

It has five modes: Scrape (one page), Crawl (a whole site by links), Map (a list of addresses), Search (search with content) and Extract (data by schema). It works as an MCP (MCP - Model Context Protocol, a standard for connecting tools to an agent), so it plugs straight into Claude Code.

Deep research - to be tested

NotebookLM-py from the memory section also has a deep research mode on Google's side, so in theory cheaper. I have not tested it seriously yet, so I treat it as a candidate, not an endorsement.

Research swarm - structure wired into the wiki

For structured research I use a skill that fires up an agent swarm (agent swarm - a swarm of independent agents working in parallel). One agent per item, in batches. Each writes a validated JSON record, and the finished report lands in my notes base. That turns a one-off research run into a permanent entry in the wiki.

🪙 Tokens - verbose output burns budget and context

Long-winded answers (output - what the agent prints in its response) cost twice. You pay for tokens and you clog the context window. The longer the output, the faster the agent loses room for what matters.

Caveman - output compression

Caveman is a skill that makes the agent talk like a caveman: no articles, no filler, no pleasantries, just the meat. It cuts an average of ~65% of output tokens (range 22-87%), keeping 100% of the technical content.

# Windows (PowerShell)
irm https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.ps1 | iex

# macOS / Linux / WSL
curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash

It has three levels: /caveman lite, /caveman full and /caveman ultra. And here is my honest caveat: in full mode the descriptions can become unreadable, especially in Polish. So I stick to lite, and for code, commits and security writing I switch to normal mode.

An important detail from the docs: Caveman only cuts the output, not the thinking tokens (reasoning - tokens the model spends on internal reasoning). It shrinks the mouth, not the brain. The biggest win is readability and speed, and the savings are a bonus.

On the radar - candidates, not endorsements

The rest of the set sits on my to-check list. I list them, but I flag clearly that I have not tested them myself yet.

• Headroom - compresses what the agent reads (input and context) by 60-95%. The input side, where Caveman handles the output.
• Ponytail - pushes the agent toward minimal code, so fewer lines and fewer tokens.
• Graphify - turns code into a knowledge graph so the agent does not read file by file.

Key takeaways

Five weak spots, five concrete moves:

1. Video - add /watch before you read a bare transcript again. For generation, check HyperFrames.
2. Design - line up three skills in order: who (UX RULER), system (UI UX Pro Max), guard (Impeccable).
3. Memory - a text wiki maintained by the agent beats RAG at small scale. If you build from scratch, start with the course.
4. Research - Firecrawl when the built-in scraper fails, and deep research only when you truly need it.
5. Tokens - Caveman cuts the output, but in Polish pick lite. Treat the rest as candidates to test.

The best part is that every one of these tools is free and open source. The worst that can happen is you run one, dislike it and uninstall it. Pick the area that hurts you most and start there.

Useful Resources

• Claude Video - the /watch skill that gives the agent sight.
• HyperFrames - generating video from HTML files.
• Impeccable - a design language plus a linter that removes AI slop.
• NotebookLM-py - NotebookLM in the Claude Code terminal.
• Firecrawl - any page turned into clean markdown.
• Caveman - token compression in the agent's answers.
• Free LLM Wiki course - how to build the agent's memory (a second brain) from scratch.

FAQ

In which areas is Claude Code weak out of the box?

Claude Code is great with code, files and commands, but it has five weak spots: it cannot see or make video, it generates generic design, it forgets after a session, it has shallow search and verbose output. Each of these gaps is patched with a separate tool or skill. These are gaps in features, not flaws in working with code.

Can Claude Code watch a YouTube video?

Not by default, but the Claude Video skill with the /watch command changes that. It takes a URL and a question, pulls captions and video frames and reads them as images, so it really "sees" the recording. When captions are missing, it turns speech into text with the whisper model. It also works well for quickly grabbing transcripts.

How do you give an AI agent memory between sessions?

The simplest way is a second brain, a text notes base in a repository that the agent reads, updates and searches. This is the LLM Wiki pattern: knowledge accumulates in files, unlike RAG where the model rediscovers everything from scratch. How to build such a base from scratch, I show step by step in the free LLM Wiki course.

What is "AI slop" and how do you avoid generic design?

AI slop is the generic look of a page that instantly gives away a front end generated by a model: the same hero layout, rounded cards and purple gradients. You avoid it by giving the agent a real design system and a linter that catches these patterns. I use the UI UX Pro Max and Impeccable skills for this, the latter has the npx impeccable detect command.

Does Caveman really save tokens and is it worth using?

Yes, Caveman cuts an average of about 65% of output tokens while keeping the full technical content. The caveat: in full mode the descriptions can be unreadable, especially in Polish, so it is better to set lite. Remember that it only shortens the output, not the model's thinking tokens.

Are these tools for Claude Code free?

Yes, all five solutions are free and open source. Some need your own keys or add-ons: Claude Video may need a whisper key for videos without captions, and Firecrawl an account for the API mode. Installation usually comes down to a single command in the terminal.