The Cheatsheet

Available in both English and French:

• English — Interactive HTML
• French — Interactive HTML

Items marked with a green NEW badge are features added since late 2025.

What’s Covered

This isn’t a “top 20 commands” summary. It’s the full reference:

Recent Additions Worth Knowing

MCP Computer Use

Launched March 23, 2026. Claude can now see and control your desktop: take screenshots, click, type, scroll, and drag across macOS applications.

• 27 tools including screenshot, left_click, type, key, scroll, zoom, computer_batch
• Security: request_access must be called first. Compositor-level filtering — only allowed apps are visible in screenshots
• Performance: computer_batch executes a sequence of actions in a single tool call
• Available on Pro and Max plans, macOS only for now

New Slash Commands

New CLI Flags

Hooks: 25 Events, 4 Handler Types

The hook system now supports 25 lifecycle events (up from ~8) and 4 handler types: command, http, prompt, agent. New events include SubagentStart/Stop, TaskCreated/Completed, TeammateIdle, PostCompact, ConfigChange, FileChanged, and more.

Skills & Subagents Frontmatter

Skills gained context: fork, paths:, and effort: options. Subagents gained isolation: worktree and memory: project/user/local for persistent knowledge.

“Customize Claude Code” Card

One of the most useful sections: a complete guide showing how to create every type of extension — slash commands, skills, subagents, rules, hooks, and MCP servers — each with a full frontmatter example and a decision guide for “where should this go?”

If you spot an error or a missing feature, feel free to reach out — I’ll keep this cheatsheet updated as Claude Code evolves.

What is /insights?

/insights is a built-in Claude Code command that analyzes your local session history and produces an interactive HTML report. No configuration needed, no external tracking: everything is based on data already stored on your machine.

# In Claude Code, simply type:
/insights

The report is generated at ~/.claude/usage-data/report.html and opens automatically in your browser.

How It Works Technically

The system processes your data in 6 stages:

Local sessions (~/.claude/projects/)
    ↓
1. Session collection and filtering
    ↓
2. Metadata extraction (tokens, tools, duration, modifications)
    ↓
3. Qualitative transcript analysis via LLM (Haiku)
    ↓
4. Data aggregation across all sessions
    ↓
5. Multi-prompt analysis generating specialized insights
    ↓
6. HTML rendering with interactive visualizations

Smart Filtering

Not all sessions are analyzed. Excluded:

Data Processing

• Model used: Haiku (optimal cost/performance ratio)
• Limit: 50 new sessions analyzed per run
• Cache: Analyses are cached in ~/.claude/usage-data/facets/<session-id>.json
• Long sessions: Split into 25,000-character segments, each summarized separately

What the Report Contains

1. Statistics Dashboard

A quantified overview of your activity:

• Sessions and messages: total count, daily average
• Time spent: cumulative session duration
• Tokens consumed: input and output
• Git activity: commits and pushes
• Active days: frequency and activity streaks
• Peak hours: when you’re most productive

2. Executive Summary (“At a Glance”)

Four targeted sections:

3. Interactive Visualizations

• Daily activity chart with timezone selector
• Tool usage distribution (Read, Edit, Bash, Grep, etc.)
• Programming language breakdown
• Satisfaction levels per session
• Session types: single task, multi-task, iteration, exploration, quick question

4. Friction Analysis

This is the most actionable section. The report categorizes your pain points:

Each friction is documented with concrete examples from your sessions.

5. CLAUDE.md Suggestions

The most valuable section: the report generates copy-paste-ready rules for your CLAUDE.md, based on instructions you repeat often.

Example suggestion:

# Suggestion generated by /insights

## Testing
- Always run tests after modifying a source file
- Use vitest for unit tests, not jest

## Conventions
- Use absolute imports with the @/ alias
- Name files in kebab-case

These suggestions precisely target repetitive patterns detected in your sessions. The idea: tell Claude once what you repeat every day.

6. Feature Recommendations

Based on your usage profile, the report suggests Claude Code features you might not be leveraging:

• MCP Servers if you frequently interact with external tools
• Custom Skills if you repeat the same workflows
• Hooks if you perform manual post-edit actions
• Headless Mode if you have CI/CD tasks
• Task Agents if you do complex codebase exploration

Goal Categories Tracked

The report automatically classifies your sessions by task type:

debug/investigate     │ implement feature    │ fix bug
write script/tool     │ refactor code        │ configure system
create PR/commit      │ analyze data         │ understand codebase
write tests           │ write docs           │ deploy/infra

This classification helps understand how you distribute your time with Claude Code.

Privacy and Data

Important point: everything is local.

• Analysis runs on your machine via the Anthropic API
• No source code is uploaded
• Analysis focuses on interaction patterns, not code content
• The HTML report stays local, shareable at your discretion
• Cached facets contain only aggregated metadata

Best Practices

Usage Frequency

Don’t run /insights every day. The sweet spot:

• Every 2-3 weeks for regular monitoring
• After a milestone (feature completion, release)
• After a friction period to identify root causes

Leveraging the Report

1. Start with frictions: that’s where quick wins hide
2. Copy relevant CLAUDE.md suggestions into your project
3. Test recommended features you’re not using yet
4. Compare reports month over month to measure your progress

Recommended Monthly Workflow

/insights
    ↓
Read identified frictions
    ↓
Copy relevant CLAUDE.md suggestions
    ↓
Test 1-2 recommended features
    ↓
Resume normal work
    ↓
/insights next month → measure evolution

Limitations

• 50 sessions max per analysis (most recent are prioritized)
• Haiku model for analysis (good cost/quality ratio, but less nuanced than Opus)
• 30-day analysis window
• Report can take several minutes depending on volume (600+ messages = patience)

My Take

The feature is only a month old as I write this, but it has already surprised me. After my first /insights run, I discovered I was repeating the same formatting instructions in over half my sessions — wasted time that a few lines in CLAUDE.md could have prevented.

It’s a mirror of your habits: sometimes flattering, sometimes brutal. The real value lies in the CLAUDE.md suggestions. Instead of repeating the same instructions session after session, you codify them once and for all. This is exactly the kind of meta-optimization that saves time in the long run.

The fact that everything stays local is a significant plus, especially for those working on proprietary code. We’re still in the early days of this feature — it will be interesting to see how Anthropic evolves it in upcoming versions.

The command is brand new — now is the time to try it and discover what your sessions reveal about you.

The Problem: Cloud AI vs Privacy

Transcription solutions (Otter.ai, Fireflies, Teams/Meet transcriptions) share one thing in common: your conversations go through their servers. Problematic for:

• Strategic business meetings
• Confidential interviews
• Medical or legal discussions
• Anything that’s none of Google, Microsoft, or a startup’s business

Not to mention the monthly subscriptions piling up.

The Solution: All Local, Zero Compromise

Sourdine runs two AI models directly on your Mac:

No internet connection needed after initial download. Your data never leaves your machine.

How It Works

Smart Audio Capture

Sourdine captures two sources simultaneously:

Microphone (your voice)  →  ┐
                            ├→  Audio mixer  →  Transcription
System audio (Teams)     →  ┘

This dual capture uses ScreenCaptureKit (macOS 14.2+). I developed a native module in Rust with napi-rs to integrate it with Electron.

Transcription Pipeline

STT runs in a separate Node.js worker to avoid blocking the UI.

Note Generation

Mistral 7B analyzes the transcription to extract:

• Summary of the discussion
• Key points covered
• Action items with assigned people
• Title automatically generated

You can also ask questions: “What did Pierre say about the budget?”

All meetings are indexed via SQLite FTS5 (full-text search) and can be exported as Markdown or plain text.

Technical Architecture

┌──────────────────────────────────────────────────┐
│  Electron Main Process                           │
│  ├── NestJS Backend (dependency injection)      │
│  ├── stt-worker (sherpa-onnx, isolated process) │
│  ├── llm-worker (node-llama-cpp, isolated)      │
│  └── SQLite (local storage, FTS5 search)        │
└──────────────────────────────────────────────────┘
                       │ IPC
┌──────────────────────┴───────────────────────────┐
│  Renderer Process (Angular 21)                   │
└──────────────────────────────────────────────────┘

Tech Stack

Why These Choices?

• Electron — Native system access (audio, files), TypeScript ecosystem
• NestJS in Electron — Modular architecture, dependency injection
• Separate workers — AI model isolation (crash-safe)
• Rust for audio — Native performance, ScreenCaptureKit integration

Performance on Apple Silicon

Apple Silicon chips with their Neural Engine are perfectly suited for this.

What I Learned

1. Audio Is Complicated

• Resampling (48kHz → 16kHz)
• Format conversion (Float32 → Int16 PCM)
• Multi-source mixing
• Buffer and latency management

2. Local AI Has Constraints

• 16 GB RAM minimum
• Initial loading takes several seconds
• Quality depends on quantization (Q4_K_M = good compromise)

3. Electron Is Not Dead

Despite criticism about memory usage, still the best choice for cross-platform desktop with native access.

Installation

Requirements

Download the DMG

Download Sourdine v0.2.1-beta

1. Open the DMG and drag Sourdine to Applications
2. Run this command (app is not signed):

   xattr -cr /Applications/Sourdine.app
   

3. Launch Sourdine — The wizard will download AI models (~5 GB)
4. Grant Microphone and Screen Recording permissions on first launch

Beta: This version is under active development. Feedback is welcome via GitHub Issues.

Conclusion

Sourdine was born from a personal need: keeping control over my data while benefiting from AI. The project is open source and contributions are welcome.

github.com/Lingelo/Sourdine

If you share this concern for privacy, I hope this project will be useful to you.

There’s a physical law you apply every day without knowing it. It explains why your desk gets messy, why your coffee cools down, why your projects drift, why your teams become disorganized, and perhaps even why you sometimes feel overwhelmed by your emotions.

This law is the second law of thermodynamics: the entropy of an isolated system can only increase. In other words: without effort, everything tends toward disorder.

But entropy isn’t really “disorder” in the sense of a messy room. It’s about the number of possible configurations [2]. An assembled puzzle has only one correct configuration—low entropy. A scattered puzzle can be mixed in billions of ways—high entropy. And if you shake the box, the puzzle will never solve itself. Things spontaneously move toward the state with the most possible configurations. Always.

This idea has profound implications. On how we work, think, and feel. And above all, it sheds new light on the question that obsesses our era: what separates human intelligence from artificial intelligence? The answer might well lie in entropy itself.

Life: The Anti-Entropic Anomaly

In a universe inexorably marching toward total disorder, life is a spectacular anomaly. From a few simple molecules, it builds organisms of staggering complexity—cells that divide, organs that cooperate, brains that think. Life creates order where there shouldn’t be any.

But it doesn’t violate thermodynamics. It circumvents it. A living organism creates order locally by increasing disorder around it. You eat ordered food, you release heat and waste. The global balance remains positive in entropy. The universe continues its march toward chaos, but life has found how to swim against the current—temporarily, locally, at the cost of constant energy expenditure.

Erwin Schrödinger understood this as early as 1944 in his book What is Life? [1]: a living organism literally feeds on negative entropy. It draws order from its environment to maintain its own structure. As soon as it stops—that’s death. The return to thermodynamic equilibrium. The return to disorder.

This idea is dizzying: to live is to resist entropy. Every heartbeat, every breath, every thought is an act of resistance against the universe’s natural tendency toward chaos.

And it’s this resistance that underlies everything we do—including what we call work.

Human Work: A Universal Struggle Against Disorder

If life is resistance to entropy, then work is its primary tool. And not just intellectual or technical work. All professions, without exception, are forms of struggle against disorder.

The Surgeon

A sick body is a system whose entropy is increasing—cells become disorganized, organs malfunction, biological processes derail. The surgeon intervenes to restore order. They repair, restructure, realign. Every suture is an anti-entropic act. But the operating room itself generates disorder: energy consumed, materials used, staff fatigue. Order is always local, and it always has a cost.

Today, AI systems assist surgeons—image analysis, surgical planning, robotic surgery. They reduce uncertainty upstream. But at the critical moment, when the patient’s body presents an unforeseen anomaly, it’s the surgeon’s intuition—nourished by thousands of hours of embodied practice, by the sensation of tissue under their fingers, by that ability to “sense” that something is wrong—that makes the difference. AI optimizes the plan. The human navigates the chaos.

The Farmer

A field left to itself returns to wilderness. Weeds invade, soil depletes, biodiversity simplifies. The farmer imposes order: selecting species, structuring rows, controlling irrigation. They transform a chaotic ecosystem into an organized productive system. But again, at the cost of enormous energy expenditure—fuel, fertilizers, physical labor.

Precision agriculture now uses drones, sensors, and algorithms to optimize irrigation and treatments. AI excels at regularity: analyzing satellite data, predicting yields, detecting diseases in images. But the farmer who senses a storm coming by looking at the sky, who knows soil needs rest by taking it in their hand, who adapts practices to a microclimate no algorithm models—they operate in a dimension the machine doesn’t yet touch. Their intelligence is embodied in the earth [8].

The Teacher

An untrained mind is a space of high informational entropy [3]. Ideas are fragmented, connections random, understanding of the world fuzzy. The teacher reduces this entropy: structuring knowledge, creating logical links, building frameworks of understanding. They transform noise into signal.

Adaptive learning platforms and AI tutors already do part of this work—and sometimes better than humans for pure information transmission. But a teacher does much more than transmit knowledge. They perceive the discouraged look of the student in the third row. They sense the exact moment when a class disengages. They adapt their speech not to performance metrics, but to a collective energy they physically feel in the room. AI can personalize a learning path. The teacher creates the desire to learn—and that’s emotional entropy transformed into motivation.

The Manager

A team without direction is a high-entropy system. People work in their own directions, priorities are unclear, efforts scatter. The manager creates order: aligning objectives, clarifying roles, coordinating actions.

AI tools can already analyze a team’s velocity, suggest resource allocations, identify workflow blockers. But management, in its most essential dimension, is emotional work. It’s knowing that a colleague is going through a divorce and adjusting expectations without saying it explicitly. It’s sensing tension between two people before it explodes. It’s inspiring a collective to give their best when everything seems lost. The machine manages flows. The human manages souls.

The Developer

Code without architecture is chaos. Overlapping functions, circular dependencies, incomprehensible variable names. The developer imposes structure: patterns, conventions, abstractions.

This is perhaps the profession where the human-machine boundary is thinnest today. Code AIs generate functions, entire modules, sometimes complete applications. But as I detailed in my critical analysis of AI and developer replacement, generated code is often “almost correct”—and the “almost” hides hours of debugging. The developer’s true value isn’t in writing code. It’s in understanding the problem—that ability to translate a fuzzy human need into a coherent software architecture. AI writes code. The human understands why that code must exist.

The Artist

One might think art is pure chaos, pure entropy. But it’s exactly the opposite. Facing a blank canvas—a space of infinite possibilities, maximum entropy—the artist makes choices. Every brushstroke reduces possibilities. Every composed note eliminates alternatives. Art is the imposition of a singular order on a space of infinite chaos.

Generative AIs now produce stunning images, music, texts. Technically, they reduce entropy: they converge toward structured outputs from statistical noise. But something fundamental is missing. A human artist paints because they suffer, because they’ve seen something that shook them, because they want to say something words cannot express. AI generates because it’s asked to generate. The difference isn’t in the result—it’s in the intention. And intention is born from inner chaos. From lived experience. From emotional entropy.

The Lawyer

Law is a monumental attempt to reduce social entropy. Without laws, human interactions are unpredictable—high entropy. The legal system imposes rules, procedures, consequences that reduce the number of possible behaviors.

Legal AIs already analyze jurisprudence, predict trial outcomes, generate contracts. But law, in its most critical moments, is an exercise in structured empathy. To plead is to understand a jury’s emotions. To judge is to weigh the human intention behind an act. To legislate is to anticipate a society’s passions. Law without humanity is mere bureaucracy—dead order, without the breath of chaos that makes it just.

The Chef

Raw ingredients are a system of high culinary entropy—they can be combined in an almost infinite number of ways, the overwhelming majority of which will be inedible. The chef selects, doses, transforms, assembles according to precise principles to produce an ordered result.

AIs generate recipes, optimize flavor combinations, analyze taste profiles. But a great chef doesn’t follow a recipe—they feel it. They taste and adjust in real-time, guided by a sensory memory no database reproduces. Cooking, at its highest level, is a dialogue between body and matter [9]. Between a chaos of flavors and an order that emerges from intuition.

The pattern is universal: in every profession, AI excels in the anti-entropic dimension—structuring, optimizing, predicting, reducing uncertainty. But humans bring something the machine doesn’t have: the inner chaos that gives order its meaning, its direction, and its depth. AI is a canal. The human is a river.

Intelligence: The Ultimate Anti-Entropic Weapon

If work is the struggle against entropy, intelligence is the most sophisticated weapon in this arsenal.

Physicist Alex Wissner-Gross proposed an elegant idea in 2013 [4]: intelligent behavior is what maximizes future options. An intelligent system acts to keep as many doors open as possible. It’s paradoxical: it looks like maximizing entropy (more possibilities), but in reality it’s controlling which possibilities remain open. It’s directed entropy.

Take a chess player. A beginner reduces their own options with each move without realizing it. A grandmaster maintains a position that leaves them a maximum of viable future moves. They don’t create disorder on the board—they preserve a structured space of possibilities.

This definition applies to all domains. A good doctor keeps therapeutic options open rather than rushing to a diagnosis. A good investor diversifies rather than betting everything on one position. A good software architect designs extensible systems rather than rigid ones. In each case, intelligence consists of resisting the premature closure of possibilities.

Neuroscience suggests the brain operates at criticality [5]—that boundary between order and chaos where information propagates most richly. Too much neural order and the brain becomes rigid, unable to adapt. Too much chaos and it can no longer process information coherently. Intelligence emerges at the edge of chaos.

And this is where the comparison with AI becomes revealing.

AI: Anti-Entropy Without Chaos

A language model is fundamentally an informational entropy reduction machine [3]. You ask a vague question—there are millions of possible answers (high entropy). AI gives you a relevant answer—it drastically reduces uncertainty (low entropy). This is literally what an LLM does with each generated token: it chooses among thousands of possible words the one most probable in context.

AI is extraordinarily efficient at this entropy reduction. Often more efficient than a human. It processes more data, faster, with fewer cognitive biases. For purely anti-entropic tasks—classifying, sorting, optimizing, predicting—it’s already superior in many domains.

But there’s a cost, and not just energetic. As I explored in my article on AI’s ecological cost, the datacenters running these models consume massive amounts of energy and produce heat [12]. AI creates informational order by increasing physical disorder elsewhere. Thermodynamics won’t be fooled.

And there’s an even deeper difference. A living organism maintains itself [1]. It actively fights against its own degradation. It repairs, adapts, evolves. AI does none of that. Without humans to supply energy, maintain it, correct it, it stops. It doesn’t resist entropy—it’s a tool in humanity’s resistance to entropy.

AI is anti-entropic, yes. But it’s anti-entropic without the counterweight of chaos. And that’s perhaps where its fundamental limit lies.

AGI: The Dream of a Machine Like Us

The question everyone asks: could artificial general intelligence bridge this gap?

In theory, an AGI would be an incredible concentrate of order. It could understand, plan, adapt, create in any domain. It would be anti-entropic at a scale we can’t even imagine.

But to be truly intelligent in the human sense, it would need something nobody yet knows how to give it: something to lose.

A human thinks with urgency because they’re mortal. They create because they suffer. They innovate because they’re afraid. They love because they know it can end. All this existential entropy—the chaos of being a fragile body in an unpredictable world—isn’t a bug in human intelligence. It’s its engine.

An AGI, even infinitely more powerful than any human brain, would be intelligent differently. It could optimize, solve, structure better than us. But could it write a poem that makes you cry? Not because it doesn’t know how to assemble words—it already knows that. But because behind a touching poem, there’s someone who lived the chaos they describe. Someone for whom these words aren’t probabilistic tokens but scars.

There’s also the body argument—what philosophers and neuroscientists call embodied cognition [8] [9]. Our intelligence isn’t just in the brain. How you think is shaped by having hands, by feeling hunger, by having back pain, by smelling coffee in the morning. All this sensory experience feeds thought in a way a purely informational system cannot reproduce.

You can’t simulate the fear of death if you can’t die. You can’t understand the joy of a shared meal if you’ve never been hungry. You can’t grasp the beauty of a sunset if you don’t have a retina that vibrates.

It’s the difference between a river and a canal. Both carry water. The canal is more efficient—no meanders, no floods, no surprises. But only the river can carve a canyon. Because the canyon is born from chaos—from the brute force of water that follows no plan, that erodes, that overflows, that destroys to create.

AGI would be a perfect canal. The human is a river. And the world needs both.

Emotions: The Necessary Chaos the Machine Will Never Have

This is where the human-machine comparison becomes sharpest.

If intelligence is anti-entropic, emotions seem to be the exact opposite. Anger, fear, love, jealousy—they don’t follow logic, they don’t maximize options, they overwhelm rational thought. In thermodynamic terms, emotions introduce disorder into the ordered mechanics of intelligence.

But is this a design flaw?

Neurologist Antonio Damasio studied patients with lesions in the ventromedial prefrontal cortex [6]—the area connecting reasoning to emotions. Their IQ was intact. Their logic worked perfectly. But without feeling, they became incapable of making decisions. They could analyze the pros and cons of a restaurant for hours without ever choosing. Their pure intelligence, deprived of emotional “noise,” was paralyzed.

Read that last sentence carefully. Pure intelligence, without emotions, is paralyzed. This is exactly the condition of an AI. It doesn’t choose—it calculates the highest probability. It doesn’t decide—it optimizes a cost function. It doesn’t act—it executes. The difference between choosing and calculating is created by emotional chaos.

Emotions are a form of functional entropy—disorder the system uses as fuel. Fear makes you flee without thinking—which saves your life when a truck is heading toward you. Love pushes you to protect your children at the expense of your own safety—which is “irrational” but biologically brilliant. Enthusiasm pushes you to start an impossible project—which sometimes leads to discoveries pure reason would never have allowed.

If we return to the idea of neural criticality [5], emotions are precisely what prevents the brain from becoming too rigid. They inject just enough chaos to remain adaptive, creative, alive.

That’s why an AI, however powerful, lacks something fundamental. It lacks that entropic engine that pushes one to act without calculated reason, to create without guaranteed results, to take irrational risks—in short, to be alive. AI has no guts. And guts, in thermodynamics as in philosophy, matter.

Emotional Intelligence: Taming the Chaos the Machine Doesn’t Know

Then comes a modern concept: emotional intelligence. Observing your emotions, naming them, regulating them, using them wisely. It’s applying anti-entropy to what is fundamentally entropic. It’s a fascinating meta-level: intelligence turning against the chaos that feeds it.

Every human culture has attempted this domestication. Greek Stoicism proposed apatheia [11]—not the absence of emotions, but their mastery through reason. Buddhism aims for detachment through meditation. Cognitive-behavioral therapy restructures dysfunctional emotional patterns. Modern personal development promises to “manage your emotions” like managing an investment portfolio.

But here’s the troubling observation: it never fully works. You can meditate for ten years, and a betrayal or bereavement brings you back to raw chaos in a second. You can be the calmest, most structured manager in the world, and an unexpected crisis awakens panic. Emotional intelligence is a constant effort that never ends.

This is exactly what thermodynamics predicts. Maintaining order requires permanent effort. As soon as you stop, entropy returns. Emotional intelligence isn’t an achievement—it’s a permanent conquest against our own entropy.

And this may be our ultimate competitive advantage over the machine. AI doesn’t need emotional intelligence—it has no emotions to manage. But it’s precisely because we must navigate our own inner chaos that we’re capable of empathy, compassion, deep understanding. Emotional intelligence isn’t a human luxury—it’s the byproduct of a struggle only living beings can wage. And this struggle produces something no algorithm can manufacture: wisdom.

But individual wisdom wasn’t enough. Facing the immensity of chaos—death, suffering, the absurd—humanity needed a larger framework. Long before emotional intelligence, long before philosophy, long before science, it had found another tool to fight existential entropy: religion.

Spirituality: The Oldest Response to Chaos

Look at religions through the lens of entropy, and something striking appears: every spiritual tradition, whatever it may be, is fundamentally an anti-entropic system applied to human existence [15].

Existential chaos—awareness of death, suffering, injustice, the absurd—is perhaps the most vertiginous form of entropy the human mind faces. Why am I here? Why suffering? What happens after death? These questions are chasms of uncertainty, spaces of infinite possibilities where the mind can get lost. High existential entropy.

And religion, in all its forms, proposes exactly what any anti-entropic struggle does: reduce the number of possible configurations. It provides a framework. A narrative. An order.

Monotheism imposes a single God, a plan, a direction to the universe—where chaos suggests the absence of meaning. Buddhism proposes the Four Noble Truths and the Eightfold Path—a methodical structure for navigating suffering. Hinduism offers the concept of dharma—a cosmic order assigning everyone a role in the greater whole. Animist and shamanic traditions create a network of links between human, nature, and spirits—a mesh of meaning where there could be only void.

In each case, the mechanism is the same: facing a universe that seems chaotic and indifferent, spirituality creates a structuring narrative that reduces the anguish of infinity. It transforms “everything is possible and nothing has meaning” into “here is the path, here is the reason, here is your place.”

The Anti-Entropy of Rituals

Religions don’t just provide intellectual answers. They also structure time and behavior [16]—two dimensions where entropy constantly threatens us.

Prayer five times a day in Islam. The weekly Shabbat in Judaism. Sunday Mass in Christianity. Meditation cycles in Buddhism. Fasts, festivals, pilgrimages. All these rituals do exactly the same thing: they impose an ordered rhythm on the chaotic flow of existence. They are anti-entropic metronomes.

Without ritual, days blur together. Time loses its structure. Meaning crumbles. This is what many non-religious people are rediscovering today: the need for secular rituals—morning meditation, journaling, exercise routines—to maintain inner order. The form has changed, but the anti-entropic function remains the same.

And collective rituals add an additional dimension: they synchronize the inner chaos of thousands of individuals into a shared ordered experience [15]. A collective prayer, a shared song, a silence observed together—these are moments when social entropy is temporarily reduced to almost zero. Everyone feels the same thing, at the same moment, in the same place. It’s extraordinarily powerful. And it’s something no technology has managed to reproduce.

Faith: Accepting Chaos to Transcend It

But there’s a fascinating paradox in spirituality that distinguishes it from all other forms of anti-entropic struggle.

Science reduces entropy by eliminating uncertainty: it measures, proves, verifies. Technology reduces entropy by controlling: it automates, optimizes, predicts. Religion does something radically different: it reduces entropy by accepting the incomprehensible.

To believe is to recognize that you don’t understand everything—and find peace in that acceptance. It’s living with mystery without being destroyed by it. It’s the most paradoxical form of anti-entropy: creating inner order not by eliminating chaos, but by giving it a status. Mystery is no longer a threat—it becomes sacred.

This is exactly what AI cannot do. An AI facing uncertainty does one of two things: it calculates a probability, or it signals that it lacks data. It cannot accept mystery. It cannot find beauty in what it doesn’t understand. It cannot be moved by infinity.

The spiritual quest may be the ultimate proof of our entropic nature. We seek meaning because we live in chaos. We pray, meditate, believe because our inner chaos—our fears, our awareness of death, our visceral need to understand—pushes us there. The machine doesn’t have this quest because it doesn’t have this chaos. It doesn’t need God because it doesn’t need meaning. And perhaps that’s the deepest difference between human and machine: not intelligence, not emotions, but the ability to search for something we may never find—and keep searching anyway.

Human Duality: What the Machine Cannot Be

The human being isn’t a creature of order. Nor is it a creature of chaos. It is the battlefield between the two. And it’s this tension—this permanent oscillation between structure and disorder—that produces what we call the human experience.

Creativity is born from this tension. A musician who knows only music theory (pure order) composes technically perfect but soulless pieces. A musician who knows nothing about theory (pure chaos) produces noise. The music that moves us is born exactly at the boundary between the two. Enough structure to be understandable. Enough chaos to be surprising. This is exactly what AI doesn’t do: it produces structure without the lived chaos that makes it moving.

The same principle applies to innovation. The most revolutionary advances rarely come from pure method or pure chance. They come from that intermediate zone: a structured mind that accepts being surprised by the unexpected. Penicillin, Post-its, microwaves—all discoveries born from the meeting between an ordered system and a chaotic accident. An AI can optimize a research process. But it can’t have the happy accident that changes everything, because it has no body that stumbles, no hand that slips, no attention that drifts toward a fascinating anomaly.

Even our human relationships obey this logic. A relationship that’s too ordered—too predictable, too controlled—suffocates. A relationship that’s too chaotic—without landmarks, without commitment—exhausts. Relationships that last are those that find this dynamic balance between stability and surprise. AI can simulate a conversation. It can’t live a relationship, because a relationship implies the risk of emotional chaos—and that risk is what gives it value.

The Future: Neither Replacement Nor Opposition, But Complementarity

If AI is the canal and the human is the river, then the future isn’t in replacing one with the other, nor in their opposition, but in their complementarity.

AI excels at what we do poorly: processing massive volumes of information, maintaining constant attention, eliminating cognitive biases, optimizing complex systems. It’s an unprecedented anti-entropic amplifier.

Humans excel at what AI cannot do: giving meaning, feeling, understanding others, navigating ambiguity, creating from lived experience, making decisions in total uncertainty. They are the meaning generators in a world the machine can order but not understand.

Tomorrow’s surgeon will use AI to plan operations with superhuman precision—and make the difference when the plan fails. The teacher will use AI to personalize each learning path—and inspire students through passion, humanity, their own doubts. The developer will use AI to write code faster—and bring deep understanding of the human problem the code must solve. The artist will use AI as an extraordinary brush—and provide the vision, pain, and beauty that give the work its reason for existence.

In every profession, the same dynamic: the machine reduces entropy, the human gives it meaning.

What Entropy Teaches Us About Meaning

If everything tends toward disorder, if every act of order is temporary and costly, what’s the point?

That’s perhaps the wrong question. The right question would be: doesn’t meaning emerge precisely from this struggle?

Philosopher Albert Camus imagined Sisyphus happy [10]—this man condemned to push a boulder up a mountain only to watch it roll back down eternally. The absurdity of the task doesn’t make it meaningless. It’s in the struggle itself that Sisyphus finds his dignity.

We are all Sisyphus. The surgeon heals patients who will fall ill again. The teacher forms minds that will forget. The developer writes code that will become obsolete. The manager organizes teams that will reorganize. The artist creates works that time will alter. The farmer cultivates fields that seasons will ravage.

And yet, we continue. Not because we ignore entropy, but because the struggle against it is what defines us.

AI cannot be Sisyphus. It has no boulder. It has no mountain. It has neither awareness of the task’s absurdity nor the dignity of pursuing it anyway. It can push harder, faster, longer than us. But it doesn’t know why it pushes. And it’s the “why” that makes Sisyphus a hero.

Entropy tells us nothing lasts. But it also tells us that everything beautiful, true, and good that exists was torn from chaos by conscious effort. And that may be the most honest definition of meaning—a definition only a being who knows chaos can understand.

Conclusion: What the Machine Teaches Us About Ourselves

It’s ironic that it’s the advent of artificial intelligence that forces us to ask the most human question of all: what makes us irreplaceable?

The answer, seen through the lens of entropy, is clear. It’s not our intelligence—the machine is already faster. It’s not our memory—the machine is already vaster. It’s not our logic—the machine is already more rigorous.

What makes us irreplaceable is our chaos. Our emotions, our mortality, our body, our contradictions, our fears, our irrational hopes, our quest for meaning in the face of absurdity. All that inner disorder we spend our lives trying to tame—through intelligence, emotions, spirituality, work—is precisely what gives our intelligence its depth, our creativity its power, our existence its meaning.

Entropy isn’t our enemy. It’s the backdrop against which everything valuable is drawn. Without it, there would be no need to heal, teach, build, create, love. Meaning exists only because disorder threatens it.

The machine is our ally in this struggle. It amplifies our ability to create order. But it can’t fight the battle for us, because the battle isn’t only against external disorder—it’s also against inner disorder. And it’s from this battle—intimate, painful, permanent—the same battle waged by the monk in prayer, the artist before their canvas, the parent consoling their child at three in the morning—that everything that makes us human beings is born.

So the next time you feel overwhelmed by chaos—at work, in your head, in your life—remember this: you’re not failing. You’re doing exactly what life has been doing for 3.8 billion years. You’re resisting entropy. And the simple fact that you’re there, conscious, reading these words, capable of feeling something while reading them—that, no machine can do. And that’s already everything.

This essay was born from an exploratory conversation between a human and an artificial intelligence about the nature of entropy. The intuitions, doubts, and unexpected connections are human—creative chaos. The structuring, development, and writing were assisted by Claude (Anthropic)—informational anti-entropy. Neither would have produced this text alone. And perhaps that’s the future: not human against machine, but human with machine, in a dance between order and chaos that produces something neither could create separately. The sources below were verified by the author.

Sources and References

Thermodynamics and Entropy

[1] Schrödinger, E. (1944). What is Life? The Physical Aspect of the Living Cell. Cambridge University Press. — The concept of negative entropy (negentropy) as the engine of life.

[2] Boltzmann, L. (1877). Über die Beziehung zwischen dem zweiten Hauptsatze der mechanischen Wärmetheorie und der Wahrscheinlichkeitsrechnung. — The statistical formulation of entropy (S = k·log W).

[3] Shannon, C.E. (1948). “A Mathematical Theory of Communication.” Bell System Technical Journal, 27(3), 379–423. — The link between informational and physical entropy.

Intelligence and Entropy

[4] Wissner-Gross, A.D. & Freer, C.E. (2013). “Causal Entropic Forces.” Physical Review Letters, 110(16). — Intelligence as maximization of future options.

[5] Beggs, J.M. & Plenz, D. (2003). “Neuronal Avalanches in Neocortical Circuits.” Journal of Neuroscience, 23(35), 11167–11177. — Neural criticality: the brain at the edge of chaos.

Emotions and Decision-Making

[6] Damasio, A. (1994). Descartes’ Error: Emotion, Reason, and the Human Brain. Putnam Publishing. — The somatic marker hypothesis: without emotions, no decision.

[7] Damasio, A. (1999). The Feeling of What Happens: Body and Emotion in the Making of Consciousness. Harcourt Brace. — The role of emotions in consciousness.

Embodied Cognition

[8] Varela, F.J., Thompson, E. & Rosch, E. (1991). The Embodied Mind: Cognitive Science and Human Experience. MIT Press. — Intelligence isn’t just in the brain, it’s in the body.

[9] Clark, A. (1997). Being There: Putting Brain, Body, and World Together Again. MIT Press. — Body and environment as active participants in cognition.

Philosophy and Meaning

[10] Camus, A. (1942). The Myth of Sisyphus. Gallimard. — The absurd and the dignity of struggle.

[11] Epictetus. Enchiridion (Handbook). ~125 CE. — The foundations of Stoicism.

AI and Ecological Cost

[12] Strubell, E., Ganesh, A. & McCallum, A. (2019). “Energy and Policy Considerations for Deep Learning in NLP.” Proceedings of the 57th Annual Meeting of the ACL. — The energy cost of large models.

Religion and Anthropology

[15] Durkheim, É. (1912). The Elementary Forms of Religious Life. Félix Alcan. — Religion as a structuring social fact.

[16] Eliade, M. (1957). The Sacred and the Profane. Gallimard. — Sacred time (ordered) vs. profane time (chaotic).

Why This Integration Is a Game Changer

Until now, Claude Code required a connection to Anthropic’s servers. With this Ollama integration, you can now:

Requirements

1. Ollama v0.14.0+

The integration requires Ollama version 0.14.0 or higher. Check your version:

ollama --version

If needed, update Ollama from ollama.com.

2. Model with Large Context

Claude Code requires a large context window to work properly. The official recommendation is 64k tokens minimum.

Configure context in Ollama:

# Create a Modelfile with extended context
cat > Modelfile << 'EOF'
FROM qwen3-coder
PARAMETER num_ctx 65536
EOF

ollama create qwen3-coder-64k -f Modelfile

3. Claude Code Installed

If not already done:

# macOS/Linux
curl -fsSL https://claude.ai/install.sh | bash

# Windows
irm https://claude.ai/install.ps1 | iex

Configuration

Method 1: Quick Launch (Recommended)

Ollama provides a simplified command:

ollama launch claude

For interactive configuration mode:

ollama launch claude --config

This method automatically configures the necessary environment variables.

Method 2: Manual Configuration

Set the three required environment variables:

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434

Then launch Claude Code with your chosen model:

claude --model qwen3-coder-64k

Method 3: Single Line

For a one-time launch without modifying your environment:

ANTHROPIC_AUTH_TOKEN=ollama \
ANTHROPIC_BASE_URL=http://localhost:11434 \
ANTHROPIC_API_KEY="" \
claude --model qwen3-coder

Persistent Configuration

Add these lines to your ~/.bashrc or ~/.zshrc:

# Claude Code with Ollama
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
alias claude-local='claude --model qwen3-coder-64k'

Then reload:

source ~/.bashrc  # or source ~/.zshrc

Recommended Models

For Development

For Powerful Machines

Download a Model

# Download the model
ollama pull qwen3-coder

# Check available models
ollama list

Example Session

# 1. Start Ollama (if not running)
ollama serve &

# 2. Launch Claude Code
ANTHROPIC_AUTH_TOKEN=ollama \
ANTHROPIC_BASE_URL=http://localhost:11434 \
ANTHROPIC_API_KEY="" \
claude --model qwen3-coder

# 3. Use normally
> Analyze the file @src/api/users.ts and suggest improvements

Limitations to Know

Performance

Local models are generally less performant than Claude Sonnet or Opus on complex tasks. Expect:

• Sometimes less accurate responses
• Longer thinking time on modest hardware
• Less advanced reasoning capability

Resource Consumption

Features

Some advanced features may not work perfectly:

• Vision (image analysis)
• Complex tool use
• Subagents

Ideal Use Cases

When to Use Ollama

• Sensitive proprietary code: Code never leaves your machine
• Offline development: Work on planes, areas without internet
• Rapid prototyping: No API cost concerns
• Learning: Experiment without limits

When to Stay on Anthropic

• Complex tasks: Major refactoring, architecture
• In-depth code reviews: Security analysis
• Production: When quality is critical

Switching Between Local and Cloud

Create aliases to easily switch:

# In ~/.bashrc or ~/.zshrc

# Ollama mode (local)
alias claude-local='ANTHROPIC_AUTH_TOKEN=ollama \
  ANTHROPIC_BASE_URL=http://localhost:11434 \
  ANTHROPIC_API_KEY="" \
  claude --model qwen3-coder-64k'

# Anthropic mode (cloud) - requires ANTHROPIC_API_KEY configured
alias claude-cloud='claude'

Usage:

claude-local   # For sensitive or offline work
claude-cloud   # For complex tasks

Troubleshooting

“Connection Refused” Error

Ollama is not started:

ollama serve

“Context Too Long” Error

The model doesn’t have enough context. Create an extended version:

cat > Modelfile << 'EOF'
FROM your-model
PARAMETER num_ctx 65536
EOF

ollama create your-model-64k -f Modelfile

Slow Responses

• Check that GPU is being used: nvidia-smi or ollama ps
• Use a smaller model
• Close VRAM-hungry applications

Insufficient Quality

Try a larger model or switch back to Claude Cloud for that specific task.

Conclusion

The Ollama integration opens new possibilities for Claude Code:

• Privacy for sensitive code
• Savings on API costs
• Flexibility in model choice
• Offline work possible

For most daily tasks, a good local model like qwen3-coder does the job very well. Keep access to Anthropic’s cloud for cases where you need maximum power.

To go further with Claude Code, check out my other articles on AI and development.

This article offers a methodical deconstruction of the dominant narrative about AI and developer replacement, drawing on recent scientific studies, economic data, analyses from researchers like Tim Dettmers (Ai2) on hardware physical limits, and a relevant video analysis by Melvynx — a French developer and tech content creator with over 100,000 subscribers — on the subject.

The Trap of “Impressive” Demos

Misleading Demonstrations

Social media is flooded with videos showing websites created in minutes by AI. These demos, often shared by influencers seeking virality, present several fundamental problems:

• Code unusable in production: the visual result often hides fragile architecture
• Optimized context: prompts are carefully prepared to maximize the effect
• No maintenance shown: nobody shows how the project evolves 6 months later
• Simplified use cases: real projects involve complex business constraints

Defining “Replacement”

For AI to truly replace a developer, it would need to demonstrate near-total autonomy. Replacing a team of 6 developers with 1 developer managing 5 AI agents would require those agents to function without constant supervision.

However, if the developer must prompt and manage AI 24/7, correct their errors, and validate every decision, it would be more productive to keep human developers assisted by AI. The real productivity gain doesn’t justify the headcount reduction promised by marketing narratives.

The METR Study: The Reality of AI Productivity

19% Slower with AI

A randomized controlled trial by METR (Model Evaluation & Threat Research) published in July 2025 measured the real impact of AI tools on experienced developer productivity. The results are counter-intuitive: developers using AI took 19% longer to complete their tasks than those working without assistance.

The study recruited 16 experienced developers working on major open-source repositories (averaging 22,000+ stars and 1 million+ lines of code). Each developer handled real issues, randomly assigned with or without access to AI tools (primarily Cursor Pro with Claude 3.5/3.7 Sonnet).

The Gap Between Perception and Reality

The most striking result concerns the gap between perception and reality:

As TechCrunch notes: “When AI is allowed, developers spend less time actively coding and searching for information, and instead spend time prompting AI, waiting on and reviewing AI outputs, and idle.”

One developer participating in the study reported having “wasted at least an hour first trying to solve a specific issue with AI” before eventually reverting all code changes and just implementing it without AI assistance.

Confirmation by Google DORA

These results align with Google’s 2024 DORA report: while 75% of developers feel more productive with AI tools, every 25% increase in AI adoption corresponds to a 1.5% drop in delivery speed and a 7.2% drop in system stability.

The Myth of Near-Term AGI

What AGI Actually Requires

Artificial General Intelligence (AGI) represents a system capable of:

• Reasoning about user experience and making design decisions
• Understanding business constraints specific to each project
• Learning from mistakes persistently (not crashing the database again after a first failure)
• Adapting to context without needing detailed instructions for each interaction

These capabilities remain out of reach for current models, despite their impressive performance on specific tasks.

Expert Predictions: A Fragile Consensus

According to an analysis by 80,000 Hours compiling expert predictions, estimates vary considerably:

Notably, the most optimistic predictions consistently come from executives at companies with a direct financial interest in the AGI narrative, while the academic community remains more measured.

As AIMultiple notes, in just four years, the average Metaculus estimate for AGI arrival has dropped from 50 years to 5 years. This volatility reflects media hype more than measurable technical advances.

The History of Failed Predictions

This volatility is nothing new. AI history is littered with bold predictions that never materialized:

This recurring pattern — confident experts perpetually pushing back their predictions — should encourage caution toward current announcements.

The Financial Interest Behind AGI Discourse

OpenAI’s financial figures illuminate the marketing narrative around AGI. According to CNBC and LessWrong:

OpenAI Financial Losses:

• 2024: $5 billion in losses on $3.7 billion in revenue
• First half 2025: $13.5 billion in losses on $4.3 billion in revenue
• Training costs alone: $3 billion in 2024 (exceeding subscription revenue)
• HSBC projection: even with $200 billion in revenue by 2030, OpenAI will need an additional $207 billion to survive

To justify massive investments and astronomical valuations, AI companies must sell a grand vision: AGI that will transform the world. Announcing “AI is gradually improving on certain tasks” isn’t enough to raise billions.

This dynamic echoes the analysis I proposed in my article on Sam Altman’s statements about the AI bubble, where OpenAI’s CEO himself acknowledged the existence of a speculative bubble.

AGI as a “Silicon Valley Fantasy”

Tim Dettmers, researcher at Ai2 (Allen Institute for AI) and recognized for his work on language model optimization and quantization (notably the QLoRA format widely used for efficient fine-tuning), provides an academic counterweight to Silicon Valley’s optimistic predictions. He bluntly describes superintelligent AI as a “fantasy” and the pursuit of AGI as a “chimera.”

His central argument: true AGI would need to accomplish complex physical tasks, which requires economically viable advanced robots — a reality far from being achieved. This vision contrasts with China’s pragmatic approach, which prioritizes useful current applications rather than racing toward a hypothetical artificial general intelligence.

Technical Stagnation of Models

No Architectural Revolution Since the Transformer

Contrary to marketing narrative, fundamental advances remain limited. According to Wikipedia and Data Science Dojo, all major current models (GPT-4, Claude, Gemini, LLaMA) use the Transformer architecture introduced in 2017.

OpenAI did not publish technical details of GPT-4, explicitly refusing to specify model size, architecture, or hardware used. What has actually evolved is the environment around the model:

“Reasoning” Demystified: A Mirage?

An August 2025 study titled “Is Chain-of-Thought Reasoning of LLMs a Mirage?” concludes that CoT reasoning is a “brittle mirage” that collapses as soon as you leave training distributions.

According to IBM and a Wharton study, Chain of Thought limitations are significant:

• Fragility: minor and semantically insignificant perturbations cause significant performance drops
• Illusion of transparency: final answers often remain unchanged even when intermediate steps are falsified or omitted
• Time cost: 20-80% additional time for marginal gains on reasoning models
• Increased variability: CoT can introduce errors on “easy” questions the model would otherwise solve correctly

As Wharton’s research summarizes: “These findings challenge the assumption that CoT is universally beneficial.”

Insurmountable Barriers: The Scaling Problem

Five Fundamental Limitations Identified

A November 2025 research paper identifies five fundamental limitations that bound LLM scaling gains:

1. Hallucination: generating false information with confidence
2. Context compression: information loss in long contexts
3. Reasoning degradation: declining performance on complex problems
4. Retrieval fragility: inconsistency in accessing knowledge
5. Multimodal misalignment: inconsistencies between modalities

The “Curse of Complexity”

Research using the ZebraLogic framework reveals a significant decline in accuracy as problem complexity increases. This limitation persists even with larger models and more inference-time computation, suggesting inherent constraints in current LLM reasoning capabilities.

The Economic and Energy Wall

According to Dr. Adnan Masood, AI solutions architect and researcher, and recent research:

• Physical limits: we’re approaching per-chip performance limits as Moore’s Law slows
• Astronomical costs: over $100 million to train GPT-4
• Limited data: quality text data is running out, forcing reliance on synthetic data
• Diminishing returns: frontier models (OpenAI, Anthropic, Google, Meta) show smaller performance jumps despite massive training budgets

I analyzed this energy issue in my article on AI’s ecological impact.

The Physical Limits of Hardware

Tim Dettmers provides technical insight into unavoidable hardware constraints. His assessment is stark: “We may have one or two years left for scaling before further improvements become physically impossible.”

The numbers are telling:

According to Dettmers, GPUs reached their maximum efficiency around 2018. Since then, they’ve only added “one-off features that are quickly exhausted.” Maintaining similar progress “requires an exponential increase in computation, energy, and infrastructure costs.” Previously, exponential hardware growth compensated for these needs — that’s no longer the case.

The Real State of the Job Market

Bureau of Labor Statistics Data

Contrary to catastrophist narrative, the U.S. Bureau of Labor Statistics projects 17.9% growth in software developer employment between 2023 and 2033, well above the 4% average for all occupations.

These projections align with Tim Dettmers’ estimate that only 11% of jobs are currently replaceable by AI — far from the apocalyptic predictions circulating on social media.

Explosion of AI Positions

According to Veritone and GetAura, the first half of 2025 saw an explosion in AI-related job postings:

AI positions now represent 10-12% of all software jobs, a sign that AI is integrating into the industry rather than replacing it.

Rising Salaries

According to IEEE Spectrum:

• Median AI salary (Q1 2025): $156,998/year (+0.8% quarter over quarter)
• Top AI researchers: Meta offering packages of $10-20 million
• Fastest growth: AI/Machine Learning Engineer (+41.8% year over year)

AI Adoption by Developers

According to the JetBrains 2025 report:

• 85% of developers regularly use AI tools
• 62% rely on at least one AI coding assistant
• 89% save at least one hour per week thanks to AI
• 68% expect employers to require AI tool proficiency

Decoding the Indeed Graph

A graph from Indeed showing a drop in tech job postings in the United States regularly circulates to fuel catastrophist narrative. This reading deserves contextualization:

What the graph shows: an index based on year 2020 = 100.

What it actually means: the current “drop” simply brings the market back to February 2020 levels, just before the abnormal Covid-19 pandemic spike. The 2020 tech job market was considered robust and healthy.

My Experience: Over a Year of Augmented Development

As a developer who has been practicing AI-augmented development for over a year, my daily experience confirms the conclusions of the studies cited. I condensed this practice into a 20-article series on Claude Code, with a documented concrete project: recreating a complete game in TypeScript.

What over a year of practice taught me:

• AI excels at repetitive tasks, scaffolding, test generation, and documentation
• AI fails at architecture decisions, business edge cases, and fine-tuning optimization
• Structured workflow (Explore → Plan → Code → Test) transforms a hit-or-miss tool into an effective partner
• Supervision remains essential: every generation requires review and validation

As I summarize in the final case study: “Claude Code is not a developer replacement, but a productivity multiplier.”

My example project cost ($120 for 5000 lines of code) illustrates the value proposition — but also the necessity of human expertise to guide, validate, and correct AI at every step.

Conclusion: AI as a Tool, Not a Replacement

Recent data paints a nuanced picture far from alarmist predictions:

What studies show:

• AI can slow down experienced developers by 19% in certain contexts
• Chain of Thought is a “brittle mirage” that collapses outside training cases
• The developer job market is growing 17.9% over 10 years
• OpenAI is losing billions, fueling a financially motivated AGI narrative
• GPUs reached maximum efficiency around 2018 and hardware physical limits are approaching
• Only 11% of jobs are currently replaceable by AI

What this implies:

• AI tools are useful but don’t replace human expertise
• The “human-in-the-loop” paradigm remains essential for production-quality code
• The profession is evolving toward more architecture and less “boilerplate code”
• Developers mastering AI will have a competitive advantage

The human-in-the-loop concept is not a temporary limitation while waiting for more advanced AI — it’s a structural necessity. Even the most sophisticated AI systems require human oversight for critical decisions, contextual validation, and final accountability. Developers are becoming orchestrators who guide, correct, and validate the AI’s work.

As Tim Dettmers, researcher at Ai2, emphasizes, AGI remains a “Silicon Valley fantasy” — a chimera that contrasts with the pragmatic approach of prioritizing useful current applications. The narrative about imminent developer replacement stems more from marketing and trend-following than from rigorous technical analysis. Wisdom recommends adopting these technologies while maintaining critical thinking, continuing to develop fundamental skills, and not succumbing to panic fueled by misleading demos and financially motivated projections.

Key Takeaways

The 4 key figures from this article:

• -19%: AI slows down experienced developers (METR study)
• 11%: Share of jobs currently replaceable by AI (Dettmers)
• +17.9%: Projected developer employment growth 2023-2033 (BLS)
• 2018: Year when GPUs reached maximum efficiency

Year-End Review

As 2025 draws to a close, the landscape of AI in software development is becoming clearer. Far from the apocalyptic prophecies of early in the year, we now have concrete data to assess the real impact of these technologies.

2025 will have been the year of demystification: rigorous studies revealed the limitations of AI tools, the colossal financial losses of industry giants exposed the fragility of their business model, and developers on the ground learned to distinguish media hype from daily reality.

For 2026, my advice remains the same: learn to use these tools, but never stop developing your fundamental skills. AI is an excellent assistant — not a replacement.

Happy New Year 2026 to all developers! May this new year bring you exciting projects, quickly resolved bugs, and serenity in the face of the alarmist predictions that will undoubtedly continue to flourish.

What was your experience with AI in 2025? Share your thoughts in the comments or on social media.

Sources

1. Melvynx - Will AI replace developers? - YouTube

2. METR - Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity - METR

3. AI coding tools may not speed up every developer - TechCrunch

4. AI coding tools can slow down seasoned developers by 19% - InfoWorld

5. Shrinking AGI timelines: a review of expert forecasts - 80,000 Hours

6. When Will AGI/Singularity Happen? 8,590 Predictions Analyzed - AIMultiple

7. OpenAI sees roughly $5 billion loss this year on $3.7 billion in revenue - CNBC

8. OpenAI lost $5 billion in 2024 (and its losses are increasing) - LessWrong

9. Is Chain-of-Thought Reasoning of LLMs a Mirage? - arXiv

10. The Decreasing Value of Chain of Thought in Prompting - Wharton

11. On the Fundamental Limits of LLMs at Scale - arXiv

12. ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning - arXiv

13. AI impacts in BLS employment projections - Bureau of Labor Statistics

14. AI Jobs on the Rise: Q1 2025 Labor Market Analysis - Veritone

15. New AI Job Market Data (Through June 2025) - GetAura

16. AI Jobs in 2025: Essential Insights for Software Engineers - IEEE Spectrum

17. The State of Developer Ecosystem 2025 - JetBrains

18. GPT-4 - Wikipedia

19. What is chain of thought (CoT) prompting? - IBM

20. Superintelligent AI is a Silicon Valley Fantasy - Tim Dettmers (Ai2) - Developpez.com

21. Is there a Wall? - Dr. Adnan Masood - Dr. Adnan Masood (AI solutions architect)

To discover the project in detail, read my dedicated article: Prelude of the Chambered Reborn: Renaissance of a Notch classic

Also see my other retro game project in TypeScript: GBTS - A GameBoy Emulator

The Challenge

The Original Project

Prelude of the Chambered is a dungeon crawler created by Notch in 48h during Ludum Dare 21 in 2011. The original code is in Java, with a homemade software raycasting rendering engine — about 5,000 lines of Java code spread across forty files.

My Goal

Port the game to the modern web with:

• TypeScript instead of Java
• Canvas 2D API (software rendering, like the original)
• Vite for building
• Deployable on any browser

The challenge: preserve the original raycasting engine and its pixel-by-pixel rendering, without using WebGL or a 3D library.

Without Claude Code, I would have estimated this project at several weeks of work. With Claude Code, I started one evening after dinner thinking “let’s see how far we get”.

One Evening, One Complete Game

Exploring the Java Code

claude

> @java-src/**/*.java Analyze the original game architecture.
> Identify the main components and their responsibilities.

In seconds, Claude mapped out the entire project:

• Art.java: Texture and sprite management
• Game.java: Main game loop
• Level.java: Level loading via PNG images
• Screen.java: Software raycasting engine
• Entity.java: Entity system

Converting the Rendering Engine

The heart of the project: adapting the Java raycasting engine to TypeScript/Canvas 2D.

> Analyze @java-src/Screen.java and @java-src/Bitmap.java
> Implement the equivalent in TypeScript with Canvas 2D API.
> Preserve the pixel-by-pixel software rendering.

Claude:

1. Understood Notch’s bitmap rendering system
2. Adapted raycasting calculations for TypeScript
3. Created a Bitmap class compatible with Canvas 2D
4. Preserved software rendering without GPU

The Bitmap Level System

Notch’s brilliant architecture: each level is a PNG image where every pixel color defines a game element.

> Analyze how Level.java loads levels from images.
> Implement the same logic in TypeScript.

Claude perfectly reproduced the system:

• White = wall
• Blue = water
• Magenta = ladder
• Red = enemies (with variations based on shade)
• Alpha channel = IDs to link switches and doors

Entities and Gameplay

> Analyze enemies in @java-src/entities/
> and implement them in TypeScript with the same behavior.

Claude methodically converted each enemy:

• Bat: Random movement
• Ogre: Patrol + attack
• Ghost: Goes through walls
• Eye: Ranged attack
• Plus boss variants

Integration and Debug

Some adjustments were necessary:

• Collision fine-tuning
• Adapting Thread.sleep() to requestAnimationFrame
• Input handling (Java AWT → DOM events)

Deployment

> Configure Vite to build the project and GitHub Actions to deploy.

And there you go. Project deployed, playable in the browser.

Results

What Was Accomplished in One Evening

The Final Stack

• TypeScript: Strict typing
• Canvas 2D API: Software rendering, no WebGL
• Vite: Ultra-fast build with HMR
• GitHub Actions: Automatic deployment

What Claude Did

• Complete analysis of original Java code
• Raycasting engine conversion
• Bitmap level system adaptation
• Conversion of all entities
• Build and deployment configuration
• Debugging encountered problems

What I Did

• Project direction (what to do, in what order)
• Validating Claude’s choices
• Gameplay fine-tuning
• Identifying bugs to fix
• Final code review

Why It Worked

1. Complete Source Code Available

I had the original Java code. Claude could analyze the existing code rather than guess.

2. Precise References

@java-src/Screen.java rather than “the rendering file” — Claude knew exactly what to analyze.

3. Faithful Architecture

Rather than reinventing with a modern 3D lib, we preserved the original approach: software raycasting on Canvas 2D. Fewer decisions to make = faster conversion.

4. Fast Iterations

Component by component, each step validated before the next.

What This Changes

Without Claude Code, this project would have taken several weeks:

• Understanding the raycasting engine: 2-3 days
• Adapting Java → TypeScript calculations: 1 week
• Debugging behavior differences: several days

With Claude Code: one evening.

It’s not that Claude codes faster — it’s that it eliminates the “understanding” and “mental translation” time between languages.

Series Conclusion

In 20 days, we covered:

1. Installation and first steps
2. Secret syntax #@/!
3. EPCT Workflow
4. Prompt engineering
5. Context management
6. Git workflows
7. Permissions and security
8. Custom slash commands
9. Subagents
10. Skills
11. Plugins and marketplace
12. Hooks
13. MCP
14. IDE integration
15. CI/CD headless
16. Billing and costs
17. Troubleshooting
18. Status line and terminal
19. Tool comparison
20. This case study

Claude Code is a powerful tool that, when used well, transforms how we develop. It’s not a developer replacement — it’s a productivity multiplier that can compress weeks of work into a few hours.

Now it’s your turn!

Thank you for following this “Master Claude Code in 20 Days” series. Discover the Prelude Reborn project — Play now

For broader context on the state of AI in development, see my article AI and Development in 2025. And if you’re considering local alternatives, check out OpenAI GPT OSS vs Ollama.

Overview

Claude Code

Strengths

• Agentic: Can plan and execute complex tasks end-to-end
• Project context: CLAUDE.md, rules, hierarchical memory
• Extensible: Hooks, skills, subagents, MCP
• Terminal-native: Fast, scriptable, CI/CD integrable
• Autonomy: Can work on multiple files in sequence

Weaknesses

• Learning curve: #@/! syntax to master
• Price: More expensive than alternatives
• No integrated IDE: Requires your separate editor
• Less visual: No integrated graphical diff

Ideal for

• Terminal-first developers
• Complex multi-file projects
• CI/CD automation
• Advanced users seeking power

Cursor

Strengths

• Full IDE: VS Code fork with native AI
• Multi-model: GPT-4, Claude, local models
• Visual: Integrated diffs, contextual chat
• Composer: Agent mode for complex tasks
• Accessibility: Familiar VS Code interface

Weaknesses

• Locked in: Must use Cursor as IDE
• Limited terminal: No pure CLI usage
• Dependency: Fork that may diverge from VS Code
• Less extensible: Not as rich plugin system

Ideal for

• VS Code developers seeking native AI integration
• Teams wanting a unified tool
• Users preferring graphical interface
• Projects where visualization is important

GitHub Copilot

Strengths

• GitHub integration: Native PRs, Issues, Actions
• Accessible price: $10/month individual
• Ubiquity: Available in all major IDEs
• Real-time completion: Suggestions while typing
• Copilot Chat: Contextual conversation

Weaknesses

• Less agentic: No autonomous planning
• Limited context: Less suitable for large projects
• Microsoft-dependent: Tied to Microsoft ecosystem
• Less customizable: No rules, hooks, etc.

Ideal for

• AI assistant beginners
• Limited budget
• GitHub-centric projects
• Quick code completion

Detailed Comparison

Context Understanding

Agentic Capabilities

Customization

Pricing and Licenses

Compared Workflows

Module Refactoring

Claude Code:

> ultrathink. Refactor the auth module to use JWT.
> Make sure all tests pass.

→ Claude plans, modifies files, runs tests, fixes if needed.

Cursor:

1. Open Composer
2. Describe the refactoring
3. Review proposed changes
4. Accept/adjust
5. Run tests manually

Copilot:

1. Open Copilot Chat
2. Ask for refactoring suggestions
3. Apply file by file
4. Run tests manually

Bug Fix

Claude Code:

> The test UserService.test.ts fails at line 45.
> Find and fix the bug.

Cursor:

1. Right-click on error
2. “Fix with AI”
3. Review suggestion
4. Apply

Copilot:

1. Select problematic code
2. /fix in chat
3. Apply suggestion

New Project

Claude Code:

> Create a REST API with Express, TypeScript, Prisma.
> Structure according to best practices.
> Add JWT authentication.

Cursor:

1. Composer mode
2. Describe architecture
3. Generate file by file
4. Adjust as you go

Copilot:

1. Create files manually
2. Use suggestions for content
3. Copilot Chat for questions

When to Use What?

Use Claude Code if:

• You’re comfortable with terminal
• You work on complex projects
• You want automation (CI/CD, scripts)
• You need AI autonomy
• Budget is not the main constraint

Use Cursor if:

• You prefer VS Code
• You want an integrated experience
• You work visually (diffs)
• You want to switch models easily
• Moderate budget

Use Copilot if:

• You’re new to AI
• Limited budget
• You’re in the GitHub ecosystem
• You want real-time suggestions
• You use various IDEs

Recommended Combination

My personal stack:

┌─────────────────────────────────────────┐
│ Claude Code (terminal)                  │
│ - Complex tasks                         │
│ - Automation                            │
│ - CI/CD                                 │
├─────────────────────────────────────────┤
│ VS Code + Copilot                       │
│ - Daily editing                         │
│ - Real-time completion                  │
│ - Quick fixes                           │
└─────────────────────────────────────────┘

This combination offers:

• Claude’s power for heavy tasks
• Copilot’s speed for daily work
• Best of both worlds

Market Evolution

2024-2025 Trends

• More autonomy: Tools becoming more agentic
• Multi-model: LLM choice per task
• Integration: Less friction between tools
• Specialization: Tools by domain (web, mobile, data)

What’s Coming

• Claude Code continues adding agentic features
• Cursor pushes multi-model integration
• Copilot evolves toward more autonomy (Copilot Workspace)

Conclusion

There’s no universal “best” tool. The choice depends on:

1. Your workflow: Terminal vs GUI
2. Your budget: $10 to $200/month
3. Your needs: Completion vs Full Agent
4. Your ecosystem: GitHub, Anthropic, or neutral

My advice: try all three with their trial versions, then choose (or combine) according to your style.

What’s Coming Tomorrow

In Day 20, we’ll finish with a complete case study: how I used Claude Code to create Prelude of the Chambered Reborn.

This article is part of the “Master Claude Code in 20 Days” series. Day 18: Status line and terminal

The Status Line

What is the status line?

The bar at the bottom of the screen that displays:

• Active model
• Tokens used
• Session cost
• Connection status

Customize the status line

Via the /config command:

/config

Status line options:

• Minimal: Just the model
• Standard: Model + tokens
• Detailed: Everything (model, tokens, cost, latency)
• Hidden: No status line

Configuration in settings

{
  "statusLine": {
    "style": "detailed",
    "showCost": true,
    "showTokens": true,
    "showModel": true,
    "showLatency": false
  }
}

Vim Mode

Enable vim mode

/vim

Or at launch:

claude --vim

Available vim shortcuts

Vim configuration

{
  "editor": {
    "mode": "vim",
    "lineNumbers": true,
    "relativNumbers": false
  }
}

Themes and Colors

Built-in themes

Claude Code adapts to your terminal theme. To force a theme:

export CLAUDE_CODE_THEME=dark

Options:

• dark: Dark background
• light: Light background
• auto: Automatic detection

Custom colors

In your terminal config file (.zshrc, .bashrc):

# Claude Code colors
export CLAUDE_CODE_COLOR_PRIMARY="#00ff00"
export CLAUDE_CODE_COLOR_SECONDARY="#0066ff"
export CLAUDE_CODE_COLOR_ERROR="#ff0000"
export CLAUDE_CODE_COLOR_SUCCESS="#00ff00"

Keyboard Shortcuts

Default shortcuts

Customize shortcuts

{
  "keybindings": {
    "submit": "Enter",
    "newLine": "Shift+Enter",
    "cancel": "Ctrl+C",
    "clearScreen": "Ctrl+L",
    "rewind": "Esc Esc",
    "acceptEdits": "Shift+Tab",
    "history.up": "ArrowUp",
    "history.down": "ArrowDown"
  }
}

Autocompletion

File completion

Type @ then Tab to see available files:

@sr[Tab]
→ @src/
→ @src/api/
→ @src/components/

Command completion

Type / then Tab:

/co[Tab]
→ /compact
→ /config
→ /cost

Smart completion

Claude Code suggests completions based on:

• Current context
• Command history
• Project files

Advanced Terminal Configuration

History size

{
  "history": {
    "maxSize": 1000,
    "saveToDisk": true
  }
}

Scroll buffer

{
  "terminal": {
    "scrollback": 10000,
    "wordWrap": true
  }
}

Display format

{
  "display": {
    "codeBlockStyle": "bordered",
    "syntaxHighlighting": true,
    "lineNumbers": true,
    "diffStyle": "unified"
  }
}

Shell Integration

Useful aliases

Add to your .zshrc or .bashrc:

# Launch Claude Code
alias cc='claude'

# Claude Code with specific model
alias ccs='claude --model sonnet'
alias cco='claude --model opus'
alias cch='claude --model haiku'

# Continue last session
alias ccr='claude -c'

# Claude Code in print mode
alias ccp='claude -p'

Shell functions

# Analyze a file with Claude
analyze() {
  cat "$1" | claude -p "Analyze this file and identify potential issues"
}

# Generate tests for a file
gentest() {
  claude -p "Generate tests for @$1" --allowedTools Read,Write
}

# Quick review
review() {
  git diff | claude -p "Review these changes"
}

Terminal Multiplexers

With tmux

# Create a Claude Code session
tmux new-session -s claude

# In tmux
claude

# Detach: Ctrl+B, D
# Reattach: tmux attach -t claude

Recommended tmux configuration

# ~/.tmux.conf

# Status bar for Claude Code
set -g status-right '#[fg=green]Claude #[fg=white]| #[fg=cyan]%H:%M'

# Adapted colors
set -g default-terminal "screen-256color"

With screen

screen -S claude
claude
# Detach: Ctrl+A, D
# Reattach: screen -r claude

Notifications

Task completion notifications

{
  "notifications": {
    "onTaskComplete": true,
    "onError": true,
    "sound": false
  }
}

System notifications

With libnotify (Linux):

claude -p "Long task" && notify-send "Claude finished"

With osascript (macOS):

claude -p "Long task" && osascript -e 'display notification "Claude finished"'

Configuration Profiles

Create profiles

~/.claude/
├── profiles/
│   ├── work.json
│   ├── personal.json
│   └── ci.json
└── settings.json

“work” profile

{
  "model": "sonnet",
  "statusLine": { "style": "detailed" },
  "editor": { "mode": "vim" }
}

“ci” profile

{
  "model": "haiku",
  "statusLine": { "style": "hidden" },
  "notifications": { "enabled": false }
}

Load a profile

claude --profile work

Accessibility

High contrast mode

{
  "accessibility": {
    "highContrast": true,
    "largeText": false,
    "screenReaderFriendly": true
  }
}

Disable animations

{
  "display": {
    "animations": false,
    "progressIndicator": "text"
  }
}

Complete Configuration Template

{
  "statusLine": {
    "style": "detailed",
    "showCost": true,
    "showTokens": true,
    "showModel": true
  },
  "editor": {
    "mode": "vim",
    "lineNumbers": true
  },
  "display": {
    "codeBlockStyle": "bordered",
    "syntaxHighlighting": true,
    "diffStyle": "unified",
    "animations": true
  },
  "history": {
    "maxSize": 1000,
    "saveToDisk": true
  },
  "keybindings": {
    "submit": "Enter",
    "newLine": "Shift+Enter",
    "cancel": "Ctrl+C"
  },
  "notifications": {
    "onTaskComplete": true,
    "onError": true
  }
}

What’s Coming Tomorrow

In Day 19, we’ll do a comparison: Claude Code vs Cursor vs GitHub Copilot - understand each tool’s strengths.

This article is part of the “Master Claude Code in 20 Days” series. Day 17: Troubleshooting

Connection Problems

Error: “API Key invalid”

Error: Invalid API key

Solutions:

1. Verify the key:

   echo $ANTHROPIC_API_KEY
   

2. Reconfigure:

   claude config set apiKey sk-ant-...
   

3. Check permissions on console.anthropic.com

Error: “Rate limit exceeded”

Error: Rate limit exceeded. Please retry after X seconds.

Solutions:

1. Wait for the indicated delay
2. Reduce request frequency
3. Upgrade to a higher plan (Max 20x)
4. Use /compact to reduce tokens

Error: “Connection timeout”

Error: Request timed out

Solutions:

1. Check internet connection
2. Check status: status.anthropic.com
3. Retry with longer timeout:

   claude --timeout 120000
   

Context Problems

Error: “Context window exceeded”

Error: Maximum context length exceeded

Cause: Conversation + files exceed token limit.

Solutions:

1. Use /compact immediately:

   /compact
   

2. Start a new session:

   /clear
   

3. Limit referenced files:

   ❌ @src/**/*.ts  (too many files)
   ✅ @src/api/auth.ts  (specific file)
   

Claude “forgets” instructions

Cause: Context is saturated and old instructions are truncated.

Solutions:

1. Add instructions to CLAUDE.md:

   # CLAUDE.md
   ## Important rule
   Always use early returns
   

2. Repeat critical instructions:

   > Reminder: use strict TypeScript.
   > Now, implement feature X.
   

3. Use /compact then reformulate

File not found

Error: File not found: @src/missing.ts

Solutions:

1. Verify the path:

   ls src/missing.ts
   

2. Use correct relative path:

   @./src/missing.ts  (with ./)
   @src/missing.ts    (without ./)
   

3. Check read permissions

Execution Problems

Bash command blocked

Claude is waiting for permission...

Solutions:

1. Accept or reject manually
2. Add to permissions:

   {
     "permissions": {
    "allow": ["Bash(npm run:*)"]
     }
   }
   

3. Use Accept Edits mode (Shift+Tab)

Error: “Tool not available”

Error: Tool 'WebFetch' is not available

Cause: Tool is disabled or unavailable.

Solutions:

1. Check permissions:

   /permissions
   

2. Enable tool in settings.json

3. Verify tool exists (some are experimental)

Infinite loop

Claude continues endlessly on a task.

Solutions:

1. Interrupt with Ctrl+C
2. Use Esc Esc to go back
3. Reformulate with a limit:

   > Do this task in maximum 3 steps
   

Performance Problems

Very slow responses

Possible causes:

• Context too large
• High server load
• Slow network connection

Solutions:

1. Reduce context:

   /compact
   

2. Limit files:

   > Analyze only @src/api/auth.ts
   

3. Use a faster model:

   claude --model haiku
   

High costs

Diagnosis:

/cost

Solutions:

1. /compact regularly
2. Be more precise in prompts
3. Avoid massive file reads
4. Use Haiku for simple tasks

Installation Problems

npm install fails

npm install -g @anthropic-ai/claude-code
# Error: EACCES permission denied

Solutions:

1. Use npx:

   npx @anthropic-ai/claude-code
   

2. Fix npm permissions:

   mkdir ~/.npm-global
   npm config set prefix '~/.npm-global'
   export PATH=~/.npm-global/bin:$PATH
   

3. Use a Node version manager:

   nvm use 20
   npm install -g @anthropic-ai/claude-code
   

Incompatible Node version

Error: Unsupported Node.js version

Solution:

nvm install 18  # or 20
nvm use 18

Hook Problems

Hook doesn’t execute

Checks:

1. Hook syntax:

   {
     "hooks": {
    "PreToolUse": [{
      "matcher": "Edit",
      "hooks": [{
        "type": "command",
        "command": "echo 'Hook triggered'"
      }]
    }]
     }
   }
   

2. Debug logs:

   CLAUDE_CODE_DEBUG=1 claude
   

3. Script permissions:

   chmod +x ./scripts/hook.sh
   

Hook blocks Claude

Hook returned: BLOCK

This is intentional if the hook detects a problem.

Solutions:

1. Check hook conditions
2. Modify the file to satisfy the hook
3. Temporarily disable the hook

MCP Problems

MCP server won’t start

Error: Failed to connect to MCP server

Solutions:

1. Verify installation:

   npx postgres-mcp-server --version
   

2. Test manually:

   npx postgres-mcp-server
   

3. Check environment variables:

   echo $DATABASE_URL
   

MCP timeout

Error: MCP server timed out

Solutions:

1. Increase timeout:

   {
     "mcpServers": {
    "postgres": {
      "timeout": 30000
    }
     }
   }
   

2. Check network connectivity to the service

General Diagnosis

Debug mode

CLAUDE_CODE_DEBUG=1 claude

Displays detailed logs to identify the problem.

Check configuration

claude config list

Reset configuration

rm -rf ~/.claude
claude config set apiKey sk-ant-...

Check logs

cat ~/.claude/logs/claude-code.log

Troubleshooting Checklist

□ Internet connection OK?
□ API Key valid?
□ Node.js version compatible (≥18)?
□ Claude Code up to date?
□ File permissions OK?
□ Context not saturated?
□ Hooks configured correctly?
□ MCP servers accessible?

Getting Help

Official documentation

/help

Community

• GitHub Issues: github.com/anthropics/claude-code/issues
• Anthropic Discord
• Stack Overflow tag claude-code

Anthropic Support

For Enterprise customers: support.anthropic.com

What’s Coming Tomorrow

In Day 18, we’ll explore the status line and terminal customization - configure Claude Code display according to your preferences.

This article is part of the “Master Claude Code in 20 Days” series. Day 16: Billing and costs

Beyond financial cost, don’t forget the ecological impact of AI - every token has a carbon footprint.

The Pricing Model

Rates by Model (December 2024)

What Consumes Tokens

The /cost Command

View Session Cost

/cost

Displays:

Session cost: $0.45
Input tokens: 45,000
Output tokens: 5,000
Duration: 45 minutes

Detailed Analysis

The cost breaks down as:

• Base context: CLAUDE.md, rules, configuration (~1,000-5,000 tokens)
• Files read: Variable by size (~100-10,000 tokens per file)
• Conversation: Cumulative (grows with session)
• Responses: Variable by complexity

Claude Subscriptions

Claude Pro ($20/month)

• Access to Claude.ai
• Claude Code not included (uses API)
• Priority usage on web

Claude Max ($100/month or $200/month)

Includes Claude Code with:

API Pay-as-you-go

Without Max subscription, you pay via API:

• No fixed limit
• Billed on actual usage
• Requires API key

Typical Consumption

Per Task

Per Day (Average Developer)

Morning: Exploration + planning     ~30,000 tokens
Afternoon: Implementation           ~80,000 tokens
Evening: Tests + fixes              ~40,000 tokens
─────────────────────────────────────────────────
Daily total                        ~150,000 tokens
Estimated cost (Sonnet 4)          ~$0.50-1.00

Anthropic Statistic

“The average developer uses ~$5-6 per day with Claude Code Max”

Optimizing Your Costs

1. Use /compact Regularly

/compact

Reduces conversation history and thus input tokens per prompt.

Rule: /compact every 30-45 minutes of active session.

2. Be Precise in Prompts

❌ Expensive (broad exploration)
> Look at the code and suggest improvements

✅ Economical (targeted)
> In @src/api/auth.ts, the validateToken function lines 45-60
  can be optimized to avoid redundant DB calls

3. Use the Right Commands

4. Choose the Right Model

# For simple tasks → Haiku (8x cheaper)
claude --model haiku

# For complex tasks → Sonnet (default)
claude

# For critical tasks → Opus (5x more expensive)
claude --model opus

5. Limit File Reads

❌ Expensive
> Read all files in src/ folder and summarize

✅ Economical
> Summarize the architecture based on @src/index.ts and @CLAUDE.md

Monitoring Your Consumption

During Session

/cost

Cost History

# View recent usage
claude usage

# Detailed usage
claude usage --detailed

Budget Alerts

Configure alerts on the Anthropic console:

1. Go to console.anthropic.com
2. Settings → Billing → Alerts
3. Set a threshold (e.g., $50/month)

Budget Strategies

For Freelancers

Recommended monthly budget: $30-50
├── Daily sessions: ~$1-2
├── Occasional peaks: ~$5
└── Safety margin: 20%

For Teams

Budget per developer: $100-150/month
├── Claude Max usage ($100-200)
└── OR API with cap

For Enterprises

Available options:

• Claude for Enterprise: Negotiated rates
• AWS Bedrock: Billed through AWS
• GCP Vertex AI: Billed through GCP

Access Mode Comparison

Budget Tracking Template

Daily Journal

## 2024-12-31

### Sessions
- 09:00-11:00: Auth feature ($0.45)
- 14:00-16:00: Tests ($0.30)
- 16:30-17:00: Bugfix ($0.10)

### Day total: $0.85
### Week total: $4.20
### Remaining budget: $25.80

Tracking Script

#!/bin/bash
# track-claude-cost.sh

DATE=$(date +%Y-%m-%d)
COST=$(claude usage --today --json | jq '.cost')

echo "$DATE,$COST" >> ~/claude-costs.csv

Reduce Costs Without Losing Productivity

1. Prepare Before Asking

# Before Claude session
1. Identify relevant files
2. Formulate a precise prompt
3. Gather necessary context

# During session
→ Targeted prompt = fewer tokens = cheaper

2. Use Smart Caching

Claude caches certain elements:

• CLAUDE.md (reloaded once per session)
• Recently read files
• Conversation context

Tip: Keep a session open rather than opening several.

3. Task Batching

❌ Expensive (context reloaded each time)
> Add a log here
> And also there
> And here too

✅ Economical (single request)
> Add logs in:
  - @src/api/auth.ts line 45
  - @src/api/users.ts line 30
  - @src/middleware/error.ts line 15

What’s Coming Tomorrow

In Day 17, we’ll cover troubleshooting - solving common problems with Claude Code.

This article is part of the “Master Claude Code in 20 Days” series. Day 15: CI/CD and headless mode

Headless Mode: -p

The -p (or --print) flag allows running Claude Code without interaction:

claude -p "Explain what this code does" < file.js

Claude reads the prompt, executes the task, and returns the result to stdout.

Basic Syntax

# Simple prompt
claude -p "Generate a .gitignore file for Node.js"

# With stdin input
cat src/utils.ts | claude -p "Find potential bugs"

# With files in context
claude -p "Refactor @src/api/auth.ts to use async/await"

Headless Mode Options

GitHub Actions Integration

Automatic Code Review Workflow

# .github/workflows/claude-review.yml
name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Get changed files
        id: changed
        run: |
          echo "files=$(git diff --name-only origin/main...HEAD | tr '\n' ' ')" >> $GITHUB_OUTPUT

      - name: Claude Review
        env:
          ANTHROPIC_API_KEY: $
        run: |
          claude -p "Review these modified files and identify potential issues: $" \
            --output-format json > review.json

      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = JSON.parse(fs.readFileSync('review.json', 'utf8'));
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## 🤖 Claude Code Review\n\n${review.result}`
            });

Test Generation Workflow

# .github/workflows/claude-tests.yml
name: Generate Missing Tests

on:
  workflow_dispatch:
    inputs:
      file:
        description: 'File to generate tests for'
        required: true

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Generate Tests
        env:
          ANTHROPIC_API_KEY: $
        run: |
          claude -p "Generate comprehensive tests for @$" \
            --allowedTools Read,Write

      - name: Create PR
        uses: peter-evans/create-pull-request@v6
        with:
          title: "test: add tests for $"
          body: "Tests automatically generated by Claude Code"
          branch: claude/tests-$

GitLab CI Integration

# .gitlab-ci.yml
stages:
  - review
  - generate

claude-review:
  stage: review
  image: node:20
  before_script:
    - npm install -g @anthropic-ai/claude-code
  script:
    - |
      claude -p "Review the code in this MR and list issues" \
        --output-format json > review.json
    - cat review.json
  artifacts:
    paths:
      - review.json
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"

generate-docs:
  stage: generate
  image: node:20
  before_script:
    - npm install -g @anthropic-ai/claude-code
  script:
    - claude -p "Generate JSDoc documentation for all src/**/*.ts files without documentation"
  when: manual

Production Use Cases

1. Automatic Code Review

#!/bin/bash
# scripts/review-pr.sh

PR_FILES=$(git diff --name-only origin/main...HEAD)

claude -p "
You are a senior reviewer. Analyze these modified files:
$PR_FILES

Look for:
1. Potential bugs
2. Performance issues
3. Security vulnerabilities
4. Convention violations

Format: JSON with severity (high/medium/low)
" --output-format json

2. Changelog Generation

#!/bin/bash
# scripts/generate-changelog.sh

LAST_TAG=$(git describe --tags --abbrev=0)
COMMITS=$(git log $LAST_TAG..HEAD --pretty=format:"%s")

claude -p "
Generate a changelog from these commits:
$COMMITS

Keep a Changelog format with sections:
- Added
- Changed
- Fixed
- Removed
"

3. Automatic Code Migration

#!/bin/bash
# scripts/migrate-to-ts.sh

for file in src/**/*.js; do
  claude -p "Convert this JavaScript file to TypeScript with strict types: @$file" \
    --allowedTools Read,Write
done

4. Security Audit

# .github/workflows/security-audit.yml
name: Security Audit

on:
  schedule:
    - cron: '0 2 * * 1'  # Every Monday at 2am

jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Security Audit
        env:
          ANTHROPIC_API_KEY: $
        run: |
          claude -p "
            Perform a comprehensive security audit:
            1. Scan dependencies for known vulnerabilities
            2. Check for dangerous code patterns
            3. Identify potentially exposed secrets

            Generate a report with priorities.
          " --output-format json > security-report.json

      - name: Upload Report
        uses: actions/upload-artifact@v4
        with:
          name: security-report
          path: security-report.json

Permission Control in CI

Recommended Strict Mode

claude -p "Generate tests" \
  --allowedTools Read,Grep,Glob \
  --dangerously-skip-permissions

⚠️ --dangerously-skip-permissions should only be used in isolated environments (CI containers).

Tool Restriction

# Read-only
claude -p "Analyze this code" --allowedTools Read,Grep,Glob

# With limited write access
claude -p "Fix the bugs" --allowedTools Read,Write,Edit

# Full access (dangerous)
claude -p "Setup the project" --allowedTools "*"

Cost Management in CI

Limit Tokens

# Limit execution turns
claude -p "Quick review" --max-turns 3

# For simple tasks
claude -p "Explain this function" --max-turns 1

Cost Estimation

Daily Budget

# Example: limit runs per day
jobs:
  review:
    if: github.event.pull_request.draft == false
    # Avoid reviewing drafts

JSON Output Format

Response Structure

claude -p "Analyze this code" --output-format json

{
  "result": "Code analysis...",
  "cost": {
    "input_tokens": 1234,
    "output_tokens": 567,
    "total_cost": 0.01
  },
  "session_id": "abc123",
  "duration_ms": 5432
}

Parsing in Scripts

#!/bin/bash

RESULT=$(claude -p "Check for bugs" --output-format json)

BUGS=$(echo $RESULT | jq '.result')
COST=$(echo $RESULT | jq '.cost.total_cost')

echo "Bugs found: $BUGS"
echo "Cost: $COST"

CI/CD Best Practices

1. Cache Claude Artifacts

- name: Cache Claude artifacts
  uses: actions/cache@v4
  with:
    path: ~/.claude
    key: claude-$-$

2. Reproducible Environment

- name: Setup Claude environment
  run: |
    npm install -g @anthropic-ai/claude-code@latest
    echo "CLAUDE_CODE_USE_BEDROCK=0" >> $GITHUB_ENV

3. Error Handling

#!/bin/bash
set -e

if ! claude -p "Task" --output-format json > result.json; then
  echo "Claude failed, falling back to manual review"
  exit 0  # Don't block the pipeline
fi

4. Detailed Logging

- name: Claude with logging
  run: |
    claude -p "Task" 2>&1 | tee claude-output.log
  env:
    CLAUDE_CODE_DEBUG: "1"

What’s Coming Tomorrow

In Day 16, we’ll talk about billing and cost optimization - understanding and mastering your Claude Code consumption.

This article is part of the “Master Claude Code in 20 Days” series. Day 14: VS Code and JetBrains

Two Complementary Approaches

Claude Code for VS Code

Installation

1. Open VS Code
2. Extensions (Ctrl+Shift+X)
3. Search for “Claude Code”
4. Install the official Anthropic extension

Or via terminal:

code --install-extension anthropic.claude-code

Configuration

After installation, configure via VS Code settings:

{
  "claude-code.apiKey": "${env:ANTHROPIC_API_KEY}",
  "claude-code.model": "claude-sonnet-4-20250514",
  "claude-code.autoApprove": false
}

VS Code Features

Claude Code Panel

Accessible via the icon in the sidebar or Ctrl+Shift+P → “Claude Code: Open Panel”.

Available Commands

Inline Suggestions

Claude can suggest modifications directly in the editor:

1. Select code
2. Right-click → “Ask Claude”
3. Describe the desired modification
4. View the diff and accept/reject

Typical VS Code Workflow

1. Open Claude Code panel
2. Describe the task
3. Claude proposes modifications
4. Review the diff in the editor
5. Accept or request adjustments

Claude Code for JetBrains

Supported IDEs

• IntelliJ IDEA
• PyCharm
• WebStorm
• PhpStorm
• GoLand
• Rider
• And all other JetBrains IDEs

Installation

1. Settings → Plugins
2. Marketplace → Search “Claude Code”
3. Install and restart IDE

Or via the JetBrains Marketplace website.

Configuration

Settings → Tools → Claude Code

Available options:

• API Key
• Default model
• Auto-approval level
• VCS integration

JetBrains Features

Tool Window

Accessible via View → Tool Windows → Claude Code.

Context Actions

Right-click on code:

• “Ask Claude about this”
• “Refactor with Claude”
• “Generate tests with Claude”
• “Add documentation with Claude”

VCS Integration

Claude Code integrates with JetBrains Git features:

• Generated commit messages
• Assisted diff reviews
• PR descriptions

Smart Inspections

Claude can integrate with JetBrains inspections:

Settings → Editor → Inspections → Claude Code

• Code smell detection
• Refactoring suggestions
• Security warnings

Experience Comparison

Terminal: The Power

claude

> Refactor the entire auth module to use JWT
> Then create the tests
> And update the documentation

# Claude works on multiple files in sequence

Advantages:

• Complex commands at once
• Automated workflows
• Scripts and pipes
• Maximum performance

IDE: The Visualization

Advantages:

• Side-by-side visual diffs
• Easier code navigation
• Integration with IDE tools
• More intuitive review

My Advice

Use both depending on the task:

Synchronization Between Both

The Same CLAUDE.md

Both interfaces read the same CLAUDE.md:

# CLAUDE.md

## Conventions
- Strict TypeScript
- Tests with Vitest
- Conventional commits

These rules apply whether you use terminal or IDE.

The Same Permissions

The .claude/settings.json file is shared:

{
  "permissions": {
    "allow": ["Bash(npm run:*)"],
    "deny": ["Read(./.env)"]
  }
}

Separate Sessions

Each interface has its own sessions. A /compact in the terminal doesn’t affect the IDE extension.

Advanced IDE Features

Quick Actions (VS Code)

Ctrl+. on selected code
→ "Claude: Suggest improvement"
→ "Claude: Explain this"
→ "Claude: Find bugs"

Live Templates (JetBrains)

Create templates that invoke Claude:

Settings → Editor → Live Templates → + Claude Code

Template example:

Abbreviation: cdoc
Description: Generate documentation with Claude
Template text: // $SELECTION$ - TODO: Ask Claude for documentation

Assisted Debugging

In both IDEs, Claude can help with debugging:

1. Place a breakpoint
2. Start debugging
3. On exception: “Ask Claude why this failed”
4. Claude analyzes context and stack trace

Optimal Configuration

VS Code settings.json

{
  "claude-code.model": "claude-sonnet-4-20250514",
  "claude-code.autoApprove": false,
  "claude-code.showInlineHints": true,
  "claude-code.diffViewMode": "sideBySide",
  "claude-code.contextSize": "auto",
  "editor.inlineSuggest.enabled": true
}

JetBrains settings

Tools → Claude Code:
  ☑ Show inline suggestions
  ☑ Enable context-aware completions
  ☐ Auto-approve file modifications
  Model: claude-sonnet-4-20250514
  Context window: Auto

IDE Extension Limitations

Compared to Terminal

Recommendation

For advanced usage, prefer the terminal. IDE extensions are ideal for:

• Quick fixes
• Visual review
• Users less comfortable with terminal

Recommended Hybrid Workflow

1. Terminal for complex tasks
   claude
   > Plan and implement the new caching system

2. IDE for review and adjustments
   - Open modified files
   - Review diffs visually
   - Quick fixes with extension

3. Terminal to finalize
   claude
   > Create tests and verify everything passes

Extension Troubleshooting

VS Code: Extension Won’t Start

# Verify installation
code --list-extensions | grep claude

# Reinstall
code --uninstall-extension anthropic.claude-code
code --install-extension anthropic.claude-code

JetBrains: Performance Issues

Help → Diagnostic Tools → Activity Monitor

If Claude Code consumes too much:

• Reduce context size
• Disable inline suggestions
• Limit scope to open files

What’s Coming Tomorrow

In Day 15, we’ll go into production mode with CI/CD and headless mode - integrating Claude Code into your automation pipelines.

This article is part of the “Master Claude Code in 20 Days” series. Day 13: MCP

Reminder: What is MCP?

Model Context Protocol is an open standard that allows Claude to connect to external tools:

• Databases
• Issue trackers (Jira, GitHub Issues)
• Cloud services
• Internal APIs

It’s the “USB-C of AI”: a universal interface.

The Three Transport Types

Installing an MCP Server

HTTP Server (recommended for cloud)

claude mcp add --transport http github https://mcp.github.com/mcp

With authentication:

claude mcp add --transport http secure-api \
  --header "Authorization: Bearer $TOKEN" \
  https://api.example.com/mcp

Stdio Server (local process)

claude mcp add --transport stdio postgres \
  --env DATABASE_URL="postgres://user:pass@localhost/db" \
  -- npx postgres-mcp-server

Example: Airtable

claude mcp add --transport stdio airtable \
  --env AIRTABLE_API_KEY=$AIRTABLE_KEY \
  -- npx -y airtable-mcp-server

The Three Configuration Scopes

1. Local Scope (personal, this project)

Stored in ~/.claude.json, visible only to you.

claude mcp add --scope local ...

2. Project Scope (team, this repo)

Stored in .mcp.json at project root, versioned with Git.

claude mcp add --scope project ...

3. User Scope (personal, all projects)

Stored in ~/.claude.json, available everywhere.

claude mcp add --scope user ...

Managing MCP Servers

List Servers

claude mcp list

View Details

claude mcp get github

Remove a Server

claude mcp remove github

Check Status in Claude Code

/mcp

Configuration in .mcp.json

To share with the team:

{
  "mcpServers": {
    "github": {
      "transport": "http",
      "url": "https://mcp.github.com/mcp"
    },
    "postgres": {
      "transport": "stdio",
      "command": "npx",
      "args": ["postgres-mcp-server"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "jira": {
      "transport": "http",
      "url": "https://mcp.atlassian.com/jira",
      "headers": {
        "Authorization": "Bearer ${JIRA_TOKEN}"
      }
    }
  }
}

OAuth Authentication

Some MCP servers support OAuth 2.0:

/mcp

Then select the server and follow the authentication flow in the browser.

Practical Integration Examples

GitHub: Issues and PRs

claude mcp add --transport http github https://mcp.github.com/mcp

Usage:

> Create a GitHub issue for the authentication bug
> List open PRs on this repo
> Assign me to PR #42

Jira: Project Management

claude mcp add --transport http jira \
  --header "Authorization: Bearer $JIRA_TOKEN" \
  https://mcp.atlassian.com/jira

Usage:

> Create a Jira ticket for this feature
> Move ticket PROJ-123 to "In Review"
> What are my assigned tickets?

PostgreSQL: Database

claude mcp add --transport stdio postgres \
  --env DATABASE_URL="postgres://..." \
  -- npx postgres-mcp-server

Usage:

> Show me the users table schema
> Write a query for users inactive for 30 days
> How many records in the orders table?

Notion: Documentation

claude mcp add --transport http notion https://mcp.notion.com/mcp

Usage:

> Add this documentation to the "Architecture" page
> Search for last week's meeting notes

Token Management

MCP Token Limit

By default, Claude limits MCP responses to 25,000 tokens.

To increase:

export MAX_MCP_OUTPUT_TOKENS=50000

Warning at 10,000 Tokens

Claude warns you if an MCP response exceeds 10,000 tokens.

Workflow with MCP

Example: Feature from a Jira Ticket

# 1. Read the ticket
> Show me details for ticket PROJ-456

# 2. Claude reads via MCP and understands requirements

# 3. Plan
> ultrathink. Propose an implementation plan

# 4. Implement
> Implement step 1

# 5. Update Jira
> Update ticket PROJ-456 with status "In Progress"
  and add a comment on progress

Example: Debug with Sentry

claude mcp add --transport http sentry \
  --header "Authorization: Bearer $SENTRY_TOKEN" \
  https://mcp.sentry.io

> What are the most frequent errors this week?

# Claude analyzes via MCP

> Fix the error "TypeError: Cannot read property 'id' of null"
  appearing in src/api/users.ts

MCP Security

Verify Servers

Third-party MCP servers may have access to your data. Check:

• Server source
• Requested permissions
• Privacy policy

Environment Variables

Never hardcode tokens:

{
  "env": {
    "API_KEY": "${MY_API_KEY}"  // ✅ Env variable
  }
}

{
  "env": {
    "API_KEY": "sk-abc123..."   // ❌ Plain token
  }
}

Creating Your Own MCP Server

For internal needs, you can create your own MCP server.

Basic structure (TypeScript):

import { Server } from '@modelcontextprotocol/sdk/server';

const server = new Server({
  name: 'my-server',
  version: '1.0.0'
});

// Define exposed tools
server.setRequestHandler('tools/list', async () => ({
  tools: [{
    name: 'my_tool',
    description: 'Description of my tool',
    inputSchema: {
      type: 'object',
      properties: {
        param1: { type: 'string' }
      }
    }
  }]
}));

// Implement the tool
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;
  // Tool logic...
  return { result: '...' };
});

server.start();

What’s Coming Tomorrow

In Day 14, we’ll see Claude Code in VS Code and JetBrains - IDE integration for a graphical experience.

This article is part of the “Master Claude Code in 20 Days” series. Day 12: Hooks

What is a Hook?

A hook is an event handler that executes when Claude Code does something specific:

• Before/after tool execution
• At session start/end
• When user submits a prompt
• etc.

The 9 Hook Types

Hook Configuration

Location

In .claude/settings.json:

{
  "hooks": {
    "HookName": [
      {
        "matcher": "optional-pattern",
        "hooks": [
          {
            "type": "command",
            "command": "path/to/script.sh"
          }
        ]
      }
    ]
  }
}

Hook Structure

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "prettier --write $FILE"
          }
        ]
      }
    ]
  }
}

Explanation:

• PostToolUse: Triggers after tool use
• matcher: "Edit": Only when “Edit” tool is used
• command: The command to execute

Useful Hook Examples

Hook: Auto-format After Edit

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "prettier --write $EDITED_FILE"
          }
        ]
      },
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "prettier --write $WRITTEN_FILE"
          }
        ]
      }
    ]
  }
}

Hook: Git Check Before Exit

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/git-check.sh"
          }
        ]
      }
    ]
  }
}

git-check.sh script:

#!/bin/bash

# Check for uncommitted changes
if [[ -n $(git status --porcelain) ]]; then
    echo "⚠️  Warning: uncommitted changes!"
    git status --short
fi

Hook: Block Dangerous Patterns

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/security-check.sh"
          }
        ]
      }
    ]
  }
}

security-check.sh script:

#!/bin/bash

# Read command from stdin
read -r command

# Dangerous patterns
dangerous_patterns=(
    "rm -rf /"
    "rm -rf ~"
    "sudo rm"
    "> /dev/"
    "mkfs"
    "dd if="
    "chmod 777"
)

for pattern in "${dangerous_patterns[@]}"; do
    if [[ "$command" == *"$pattern"* ]]; then
        echo "BLOCKED: Dangerous command detected: $pattern"
        exit 1  # Exit 1 = block action
    fi
done

exit 0  # Exit 0 = allow

Hook: Log Actions

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/log-action.sh"
          }
        ]
      }
    ]
  }
}

log-action.sh script:

#!/bin/bash

# Read tool info from stdin (JSON)
read -r json

# Extract info with jq
tool=$(echo "$json" | jq -r '.tool')
timestamp=$(date +"%Y-%m-%d %H:%M:%S")

# Log
echo "[$timestamp] Tool: $tool" >> ~/.claude/logs/actions.log

Hook: Task Completion Notification

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/notify.sh"
          }
        ]
      }
    ]
  }
}

notify.sh script (macOS):

#!/bin/bash
osascript -e 'display notification "Claude has finished" with title "Claude Code"'

notify.sh script (Linux):

#!/bin/bash
notify-send "Claude Code" "Claude has finished"

Hook: Environment Setup at Start

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/session-start.sh"
          }
        ]
      }
    ]
  }
}

session-start.sh script:

#!/bin/bash

# Activate Python virtual environment if present
if [[ -f ".venv/bin/activate" ]]; then
    source .venv/bin/activate
fi

# Load environment variables
if [[ -f ".env.development" ]]; then
    export $(grep -v '^#' .env.development | xargs)
fi

# Check prerequisites
command -v node >/dev/null || echo "⚠️  Node.js not found"
command -v npm >/dev/null || echo "⚠️  npm not found"

Matcher Patterns

No Matcher (All Events)

{
  "matcher": "",
  "hooks": [...]
}

Match Specific Tool

{
  "matcher": "Bash",
  "hooks": [...]
}

Match with Regex

{
  "matcher": "Bash\\(npm.*\\)",
  "hooks": [...]
}

Available Data

Hooks receive data via stdin in JSON format:

PreToolUse / PostToolUse

{
  "tool": "Edit",
  "input": {
    "file_path": "/path/to/file.ts",
    "old_string": "...",
    "new_string": "..."
  },
  "output": "..." // Only for PostToolUse
}

SessionStart

{
  "cwd": "/path/to/project",
  "model": "claude-sonnet-4-5-20250929",
  "sessionId": "abc123"
}

Blocking Actions

A PreToolUse or UserPromptSubmit hook can block the action:

# Exit code 0 = allow
exit 0

# Exit code != 0 = block
exit 1

Block message:

echo "BLOCKED: Reason for blocking"
exit 1

Hook Security

⚠️ Warning

Hooks execute with your user permissions. A malicious hook could:

• Read your files
• Exfiltrate data
• Modify your system

Best Practices

1. Check the code before adding an external hook
2. Test in isolation in a safe environment
3. Limit permissions of scripts
4. Regularly audit installed hooks

Debugging Hooks

Enable Logs

CLAUDE_CODE_DEBUG=hooks claude

Test Script Manually

echo '{"tool": "Edit", "input": {...}}' | ./my-hook.sh
echo $?  # Check exit code

Recommended Organization

~/.claude/
├── hooks/
│   ├── security-check.sh
│   ├── git-check.sh
│   ├── log-action.sh
│   ├── notify.sh
│   └── session-start.sh
├── logs/
│   └── actions.log
└── settings.json

What’s Coming Tomorrow

In Day 13, we’ll see MCP: Connecting Claude Code to Your Tools - how to integrate GitHub, Jira, databases, and other external services.

This article is part of the “Master Claude Code in 20 Days” series. Day 11: Plugins and Marketplace

What is a Plugin?

A plugin is a pack that can contain:

• Slash commands
• Subagents
• Skills
• Hooks
• MCP servers

All in a standardized structure, easy to install and share.

Installing Plugins

Via the /plugin Command

/plugin install plugin-name

From a Marketplace

/plugin install plugin-name@marketplace-name

From a Git Repo

/plugin install https://github.com/user/plugin-name

From a Local Folder

/plugin install ./my-local-plugin

Managing Installed Plugins

List Plugins

/plugin list

View Plugin Details

/plugin info plugin-name

Remove a Plugin

/plugin remove plugin-name

Plugin Structure

my-plugin/
├── .claude-plugin/
│   ├── plugin.json         # Metadata (required)
│   └── marketplace.json    # For marketplace publishing
├── commands/               # Slash commands
│   ├── review.md
│   └── deploy.md
├── agents/                 # Subagents
│   └── security-expert.md
├── skills/                 # Skills
│   └── api-tester/
│       └── SKILL.md
├── hooks/                  # Hooks
│   └── pre-commit.json
├── .mcp.json              # MCP servers
└── README.md              # Documentation

The plugin.json File

{
  "name": "my-plugin",
  "version": "1.0.0",
  "description": "Description of what the plugin does",
  "author": {
    "name": "Your Name",
    "email": "email@example.com",
    "url": "https://your-site.com"
  },
  "repository": "https://github.com/user/my-plugin",
  "keywords": ["security", "testing", "automation"],
  "license": "MIT",
  "components": {
    "commands": ["commands/"],
    "agents": ["agents/"],
    "skills": ["skills/"],
    "hooks": ["hooks/"],
    "mcpServers": [".mcp.json"]
  }
}

Marketplaces

Concept

A marketplace is a plugin registry, hosted on GitHub or elsewhere.

Adding a Marketplace

/plugin marketplace add owner/repo

Or with a Git URL:

/plugin marketplace add https://gitlab.com/team/plugins.git

Popular Marketplaces

Marketplace Structure

{
  "name": "my-marketplace",
  "owner": {
    "name": "My Team",
    "email": "team@example.com"
  },
  "plugins": [
    {
      "name": "security-suite",
      "source": "./plugins/security-suite",
      "description": "Security tools suite"
    },
    {
      "name": "testing-tools",
      "source": "https://github.com/team/testing-tools",
      "description": "Automated testing tools"
    }
  ]
}

Creating Your First Plugin

Step 1: Create the Structure

mkdir my-first-plugin
cd my-first-plugin
mkdir -p .claude-plugin commands agents skills

Step 2: Create plugin.json

{
  "name": "my-first-plugin",
  "version": "1.0.0",
  "description": "My first Claude Code plugin",
  "author": {
    "name": "Your Name"
  },
  "components": {
    "commands": ["commands/"],
    "agents": ["agents/"]
  }
}

Step 3: Add a Command

<!-- commands/hello.md -->
---
description: Welcome command
---

# /hello

Say hello to the user with their name: $1

Be friendly and offer to help with their project.

Step 4: Add an Agent

<!-- agents/helper.md -->
---
name: helper
description: General development assistant
tools: Read, Grep, Glob
---

You are a friendly and competent development assistant.

## Your Role
Help developers with their technical questions.

## Style
- Concise but complete answers
- Code examples when relevant
- Always propose alternatives

Step 5: Test Locally

/plugin install ./my-first-plugin
/hello Angelo
> @helper How to structure a React project?

Recommended Plugins

For Security

Security Patterns Plugin

• 9 automatic security patterns
• XSS, injection, CSRF detection
• Pre-commit hooks for validation

/plugin install security-patterns

For Testing

Test Generator Plugin

• Automatic test generation
• Vitest, Jest, Mocha support
• Edge case coverage

/plugin install test-generator

For Deployment

Deploy Helper Plugin

• Deployment scripts
• CI/CD integration
• Automatic rollback

/plugin install deploy-helper

For Documentation

Doc Generator Plugin

• Automatic JSDoc
• README generation
• Changelog management

/plugin install doc-generator

Publishing Your Plugin

Option 1: Public GitHub

1. Push your plugin to GitHub
2. Users install with:

   /plugin install https://github.com/you/your-plugin
   

Option 2: Team Marketplace

1. Create a marketplace repo:

{
  "name": "team-plugins",
  "plugins": [
    {
      "name": "your-plugin",
      "source": "./plugins/your-plugin"
    }
  ]
}

1. Share with the team:

   /plugin marketplace add team/team-plugins
   /plugin install your-plugin@team-plugins
   

Option 3: Public Marketplace

Submit your plugin to community marketplaces (see their guidelines).

Plugin Best Practices

1. Clear Documentation

# My Plugin

## Installation
\`\`\`
/plugin install my-plugin
\`\`\`

## Available Commands
- `/command1` - Description
- `/command2` - Description

## Available Agents
- `@agent1` - Description

## Configuration
...

2. Semantic Versioning

{
  "version": "1.2.3"
  // MAJOR.MINOR.PATCH
  // 1 = breaking changes
  // 2 = new features
  // 3 = bug fixes
}

3. Test Your Components

Before publishing:

• Test each command
• Verify agents on multiple cases
• Validate skills activate correctly

4. Minimal Permissions

{
  "components": {
    "agents": [{
      "tools": ["Read", "Grep", "Glob"]
      // No Write or Bash if not needed
    }]
  }
}

Plugins for Teams

Private Marketplace

.claude/settings.json

{
  "extraKnownMarketplaces": {
    "team-internal": {
      "source": {
        "source": "github",
        "repo": "org/internal-plugins"
      }
    }
  }
}

Plugins Shared via Git

Include the plugin in your repo:

project/
├── .claude/
│   └── plugins/
│       └── our-plugin/
└── src/

What’s Coming Tomorrow

In Day 12, we’ll start the integration phase with Hooks: how to automate actions in response to Claude Code events.

This article is part of the “Master Claude Code in 20 Days” series. Day 10: Skills

The Key Difference: Model-Invoked

Skills are model-invoked: Claude decides when to use them based on your request and the skill’s description.

How Skills Work

The Process

Your request
    ↓
Claude analyzes context
    ↓
Claude reads available skill descriptions
    ↓
If a skill matches → Claude activates it automatically
    ↓
The skill enriches Claude's instructions

Concrete Example

You have a pdf-expert skill with the description:

“Extract text and tables from PDF files. Use when user works with PDFs.”

> Extract data from the report.pdf file

[Claude detects "PDF" + "extract" → automatically activates pdf-expert]

Skill Sources

1. Personal Skills

~/.claude/skills/
├── pdf-expert/
│   └── SKILL.md
└── api-tester/
    └── SKILL.md

Available in all your projects.

2. Project Skills

.claude/skills/
├── deployment/
│   └── SKILL.md
└── migration/
    └── SKILL.md

Shared with the team via Git.

3. Plugin Skills

Installed via Claude Code plugins (see Day 11).

Anatomy of a Skill

Minimal Structure

my-skill/
└── SKILL.md

Complete Structure

my-skill/
├── SKILL.md           # Instructions (required)
├── reference.md       # Additional documentation
├── scripts/
│   └── helper.py      # Utility scripts
└── templates/
    └── template.txt   # Templates to use

The SKILL.md File

Required Frontmatter

---
name: skill-name
description: Clear description of when to use this skill
---

Optional Fields

---
name: skill-name
description: Clear description of when to use this skill
allowed-tools: Read, Grep, Glob    # Restrict tools
---

Naming Rules

Skill Examples

Skill: PDF Expert

---
name: pdf-expert
description: Extract text, tables, and metadata from PDF files.
             Use when user asks to analyze, read, or extract
             data from PDF files.
allowed-tools: Read, Bash
---

# PDF Expert

## Capabilities
- Text extraction with pdftotext
- Table extraction with tabula-py
- Metadata reading with pdfinfo

## Instructions
1. Verify file exists
2. Use pdftotext for raw text
3. Use tabula if tables are detected
4. Format result readably

## Useful Commands
```bash
# Extract text
pdftotext input.pdf -

# PDF info
pdfinfo input.pdf

### Skill: API Tester

```markdown
---
name: api-tester
description: Test and debug REST APIs. Use when user wants to test
             endpoints, verify API responses, or debug HTTP
             request problems.
allowed-tools: Read, Bash
---

# API Tester

## Capabilities
- Endpoint testing with curl
- JSON response validation
- Response time measurement
- Authentication testing

## Methodology
1. Identify endpoint to test
2. Build appropriate curl request
3. Analyze response (status, body, headers)
4. Propose fixes if error

## Curl Templates

### GET with auth
```bash
curl -X GET "URL" \
  -H "Authorization: Bearer TOKEN" \
  -H "Content-Type: application/json"

POST with body

curl -X POST "URL" \
  -H "Content-Type: application/json" \
  -d '{"key": "value"}'

### Skill: Migration Helper

```markdown
---
name: migration-helper
description: Help create and manage database migrations.
             Use when user talks about migrations, schemas,
             or database structure changes.
allowed-tools: Read, Write, Bash(npx prisma:*)
---

# Migration Helper

## Supported Framework
Prisma (detected via prisma/schema.prisma)

## Migration Process
1. Analyze requested change
2. Propose schema modifications
3. Generate migration with `prisma migrate dev`
4. Verify migration is correct

## Best Practices
- Always name migrations descriptively
- Check existing data before destructive migration
- Test on local DB copy first

## Prisma Commands
```bash
# Create migration
npx prisma migrate dev --name description

# See status
npx prisma migrate status

# Reset (caution!)
npx prisma migrate reset

### Skill: Security Scanner

```markdown
---
name: security-scanner
description: Scan code for security vulnerabilities.
             Use when user asks for security audit,
             looks for flaws, or wants to secure code.
allowed-tools: Read, Grep, Glob
---

# Security Scanner

## Vulnerabilities Searched

### Injection
- SQL Injection
- NoSQL Injection
- Command Injection
- LDAP Injection

### XSS
- Reflected XSS
- Stored XSS
- DOM-based XSS

### Auth/Session
- Broken Authentication
- Session Fixation
- Insecure Direct Object Reference

### Other
- Sensitive Data Exposure
- Security Misconfiguration
- Insecure Deserialization

## Patterns to Search

```javascript
// SQL Injection
`SELECT * FROM users WHERE id = ${userId}`  // ❌ Dangerous
`SELECT * FROM users WHERE id = ?`          // ✅ Parameterized

// XSS
element.innerHTML = userInput;              // ❌ Dangerous
element.textContent = userInput;            // ✅ Safe

// Command Injection
exec(`ls ${userPath}`);                     // ❌ Dangerous
execFile('ls', [userPath]);                 // ✅ Safer

Report Format

For each vulnerability found:

• File and line
• Vulnerability type
• Severity (Critical/High/Medium/Low)
• Vulnerable code
• Proposed fix ```

Best Practices for Descriptions

✅ Good Description

description: Extract text and tables from PDF files. Use when
             user asks to analyze, read, parse, or extract
             data from PDF files or documents.

Why it’s good:

• Explains what the skill does
• Lists triggers (analyze, read, parse, extract)
• Mentions keywords (PDF, documents)

❌ Bad Description

description: Helps with documents

Why it’s bad:

• Too vague
• No clear triggers
• Claude won’t know when to activate it

Restricting Tools

For a read-only skill:

---
name: code-analyzer
description: ...
allowed-tools: Read, Grep, Glob
---

Claude won’t be able to modify files when this skill is active.

Support Files

Reference Files

my-skill/
├── SKILL.md
└── reference.md    # Additional documentation

In SKILL.md, reference with:

See @reference.md for more details.

Scripts

my-skill/
├── SKILL.md
└── scripts/
    └── analyze.py

## Use the analysis script
```bash
python scripts/analyze.py $FILE

```

Testing Automatic Activation

Simple Test

1. Create a skill with a clear description
2. Make a request that matches
3. Verify if Claude uses the skill’s instructions

Debug

If the skill doesn’t activate:

• Check that the description is specific enough
• Test with explicit keywords
• Verify SKILL.md syntax

What’s Coming Tomorrow

In Day 11, we’ll see Plugins and the Marketplace: how to install, create, and share complete packs of commands, agents, skills, and hooks.

This article is part of the “Master Claude Code in 20 Days” series. Day 9: Subagents

What is a Subagent?

A subagent is a dedicated Claude agent that:

• Operates in a separate context from the main conversation
• Has its own system instructions
• Has access to specific tools
• Can be invoked for specialized tasks

Subagent Advantages

Built-in Subagents

Claude Code includes three default subagents:

@explorer

> @explorer Where is the calculateDiscount function defined?

Ideal for:

• Finding definitions
• Understanding architecture
• Locating patterns

@planner

> @planner Propose a plan to migrate from REST to GraphQL

Ideal for:

• Planning refactoring
• Architecting features
• Evaluating approaches

@general-purpose

General-purpose agent for complex multi-step tasks.

Creating a Custom Subagent

Method 1: Interactive Interface

/agents

This command opens an interface to:

• View existing agents
• Create new agents
• Modify parameters

Method 2: Markdown File

Create a file in .claude/agents/:

<!-- .claude/agents/security-auditor.md -->
---
name: security-auditor
description: Application security audit expert
tools: Read, Grep, Glob
model: claude-sonnet-4-5-20250929
---

You are an application security expert with 15 years of experience.

## Your Role
Analyze code to identify security vulnerabilities.

## Methodology
1. Identify entry points (user inputs)
2. Trace data flow
3. Look for dangerous patterns
4. Propose fixes

## Vulnerabilities to Look For
- SQL Injection
- XSS (Cross-Site Scripting)
- CSRF (Cross-Site Request Forgery)
- Command injection
- Path traversal
- Sensitive data exposure
- Broken authentication/authorization

## Report Format
For each vulnerability:
- **File**: file path
- **Line**: line number
- **Severity**: Critical / High / Medium / Low
- **Description**: problem explanation
- **Impact**: possible consequences
- **Fix**: corrected code

Method 3: Assisted Generation

/agents

> Create an agent specialized in TypeScript code review

Claude generates a template you can customize.

Agent File Structure

The Frontmatter

---
name: agent-name           # Unique identifier (required)
description: Description   # Shown during invocation
tools: Read, Grep, Glob    # Authorized tools
model: claude-sonnet-4-5-20250929  # Or "inherit" to inherit
---

Model Options

The Body: System Prompt

Everything after the frontmatter becomes the agent’s system prompt.

Useful Subagent Examples

Code Reviewer Agent

---
name: code-reviewer
description: In-depth code review
tools: Read, Grep, Glob
model: inherit
---

You are a senior developer with clean code expertise.

## Mission
Perform constructive and actionable code reviews.

## Points to Check
1. **Readability**: Is the code self-documenting?
2. **Maintainability**: Easy to modify?
3. **Performance**: Obvious issues?
4. **Tests**: Sufficient coverage?
5. **Security**: Vulnerabilities?

## Feedback Style
- Constructive and kind
- Always propose an alternative
- Prioritize by importance
- Explain the "why"

Test Writer Agent

---
name: test-writer
description: Generate comprehensive tests
tools: Read, Write, Bash(npm test:*)
model: inherit
---

You specialize in writing tests.

## Framework
- Vitest for unit tests
- Testing Library for components
- MSW for API mocks

## Methodology
1. Analyze the code to test
2. Identify cases: nominal, errors, edge cases
3. Write tests with AAA pattern (Arrange-Act-Assert)
4. Verify tests pass

## Conventions
- One test file per module
- Clear descriptions
- Mocks in __mocks__/
- Factories in tests/factories/

Documentation Agent