AI
-
Ever wanted your CLAUDE.md to automatically update from your current session before the next compact? There’s a skill for that and it’s been helpful. In case you missed it, here’s a link to the skill:
-
Managing Your Context Window in Claude Code
If you’re using Claude Code, there’s a feature you should know about that gives you visibility into how your context window is being used. The
/contextskill breaks everything down so you can see exactly where your tokens are going.Here’s what it shows you:
- System prompt – the base instructions Claude Code operates with
- System tools – the built-in tool definitions
- Custom agents – any specialized agents you’ve configured
- Memory files – your CLAUDE.md files and auto-memory
- Skills – any skills loaded into the session
- Messages – your entire conversation history
Messages is where you have the most control, and it’s also what grows the fastest. Every prompt you send, every response you get back, every file read, every tool output; it all shows up in your message history.
Then there’s the free space, which is what’s left for actual work before a compaction occurs. This is the breathing room Claude Code has to think, generate responses, and use tools.
You’ll also see a buffer amount that’s reserved for auto-compaction. You can’t use this space directly, it’s set aside so Claude Code has enough room to summarize the conversation and hand things off cleanly.
Why This Matters
Understanding your context usage helps you work more efficiently. A few ways to keep your context lean:
- Start fresh sessions for new tasks instead of reusing a long-running one
- Be intentional about file reads — only read what you need, not entire directories
- Use sub-agents — when you delegate work to a sub-agent, it runs in its own context window instead of yours. All those file reads, tool calls, and intermediate reasoning happen over there, and you just get the result back. It’s one of the best ways to preserve your primary context for the work that actually needs it.
- Trim your CLAUDE.md — everything in your memory files loads every session, so keep it tight
I’ll dig into sub-agents more in a future post. For now, don’t forget about
/context -
I published an Agentic Maturity Model on GitHub, a mental framework for thinking about and categorizing AI tools. It’s open to contributions and I’m looking for coauthors.
-
As you’ve probably noticed, something is happening over at Anthropic. They are a spaceship that is beginning to take off.
-
Are We Becoming Architects or Butlers to LLMs?
In a recent viral post , Matt Shumer declares dramatically that we’ve crossed an irreversible threshold. He asserts that the latest AI model…
-
Don’t sleep on OpenClaw. There are a ton of people building with it right now who aren’t talking about it yet. The potential is real, and when those projects start surfacing, it’s going to turn heads. Sometimes the most exciting stuff happens quietly before it hits the mainstream.
-
REPL-Driven Development Is Back (Thanks to AI)
So you’ve heard of TDD. Maybe BDD. But have you heard of RDD?
REPL-driven development. I think most programmers these days don’t work this way. The closest equivalent most people are familiar with is something like Python notebooks—Jupyter or Colab.
But RDD is actually pretty old. Back in the 70s and 80s, Lisp and Smalltalk were basically built around the REPL. You’d write code, run it immediately, see the result, and iterate. The feedback loop was instant.
Then the modern era of software happened. We moved to a file-based workflow, probably stemming from Unix, C, and Java. You write source code in files. There’s often a compilation step. You run the whole thing.
The feedback loop got slower, more disconnected. Some languages we use today like Python, Ruby, JavaScript, PHP include a REPL, but that’s not usually how we develop. We write files, run tests, refresh browsers.
Here’s what’s interesting: AI coding assistants are making these interactive loops relevant again.
The new RDD is natural language as a REPL.
Think about it. The traditional REPL loop was:
- Type code
- System evaluates it
- See the result
- Iterate
The AI-assisted loop is almost identical:
- Type (or speak) your intent in natural language
- AI interprets and generates code
- AI runs it and shows you the result
- Iterate
You describe what you want. The AI writes the code. It executes. You see what happened. If it’s not right, you clarify, and the loop continues.
This feels fundamentally different from the file-based workflow most of us grew up with. You’re not thinking about which file to open, You’re thinking about what you want to happen, and you’re having a conversation until it does.
Of course, this isn’t a perfect analogy. With a traditional REPL, you have more control. You understood exactly what was being evaluated because you wrote it.
>>> while True: ... history.repeat() -
I usually brainstorm spec docs using Gemini or Claude, so if you are like me, this prompt is interesting insight into your software decisions.
Based off our previous chats and the previous documents you've helped me with, provide a detailed summary of all my software decisions and preferences when it comes to building different types of applications. -
Here’s a tip: if you ask Claude (via an API not Code) to Vibe a typing hacker game make sure to tell it not to return valid exploits. I asked Claude to use actual Python code snippets in the game today and… GitHub’s security scanner was not happy with me. Oopsie doopsie. Lesson learned!
-
Knowledge Without a Knower
How do we define knowledge in the age of AI? Can new knowledge even be created if we’re outsourcing our thinking to the models or the systems we built around the models?
Let’s start with what knowledge actually is. Traditionally, to know something, you have to believe it’s true and have some justification for that belief. It’s implicit knowledge earned through experience, study, or reasoning.
AI doesn’t work that way. To the tools, it’s a probabilistic map of patterns extracted from massive amounts of text. There’s no belief, no understanding in the human sense. It’s knowledge without a knower.
That distinction matters more than we might think.
From Retention to Curation
The way we work with knowledge is shifting. For centuries, the paradigm was retention: memorize facts, write things down, build personal libraries of information.
Now we have tools that can do that for us, often better and faster than we ever could.
So what’s our new role?
Curation.
The skills that matter now are about what we can retrieve, what we can verify, and what we can synthesize.
We don’t need to remember everything, we need to know how to find it, evaluate it, and combine it in useful ways.
The Skills We Actually Need
If we’re not going to be the primary repositories of knowledge anymore, what should we focus on?
Spotting bullshit. This might be the most important skill of the next decade. When the tool outputs something that doesn’t match what we know to be true, can we catch it? AI systems are confident even when they’re wrong. They don’t hedge. They don’t say “I’m not sure about this.” So we need that internal alarm that goes off when something doesn’t add up.
Asking good questions. This has always been important, but it’s now essential. Understanding the problem means knowing where the gaps in your knowledge actually lie. A well-formed question is half the answer. An AI can give you a thousand responses, but only a good question will get you a useful one.
Reasoning about reasoning. How did the system arrive at that answer? What steps did it take? Why does it think that’s the case? We need to be able to trace the logic, not just accept the output. This is meta-cognition applied to our tools.
The Human in the Loop
New knowledge will continue to need humans. Not for the grunt work of data processing or pattern matching, AI can handle that better than we ever could.
Instead our role is to identify the anomalies. We need to become detectives, finding the errors in the data. Skepticism will be extremely valuable in the times ahead.
Being a critical thinker. We need to be able to evaluate the evidence, weigh the pros and cons, and make informed decisions.
In computing, we see error correcting used in the semiconductor industry, and we see a different technique also used in the quantum computing industry. And while reducing the amount of errors in a given system will continue to be important, what we really after here?
Well, the truth, right?
I propose we come up with a new name for truth. I think it should be called “HAT” or a “human accepted truth.”
The aggregate of HATs is what we shall call “knowledge.” Knowledge is the sum of all human accepted truths.