14:03Mansel Scheffel · Tutorial
The 5 Rules of Building With Claude Code
A 14-minute pyramid framework for AI system design — KISS, need-first, clean data, human gate, model portability — and why the boring stuff is the product.
June 29thThe argument in one line.
Most YouTube-style Claude mission control dashboards are context bloat — what you actually need is an observability-first daemon that surfaces token spend, cache hit rate, and MCP latency in real time.
Read if. Skip if.
READ IF YOU ARE…
- Claude Code power users spending $50-200/month who have zero visibility into token spend, cache hits, or MCP latency
- Developers skeptical of YouTube mission control demos who want a leaner, observability-first alternative
- Engineers who already understand OpenTelemetry and want to apply it to AI tooling costs and security posture
- Anyone building with multiple Claude skills or agents who suspects their setup is leaking budget without knowing where
SKIP IF…
- Beginners to Claude Code — this assumes comfort with daemons, OTEL logs, and JSONL processing
- Viewers who want a pre-built dashboard they can install in 2 minutes — this is a build-your-own walkthrough
The full version, fast.
Most Claude mission control dashboards add context bloat and complexity without adding real value — the contrarian case here is that observability should come first, and named-agent microservices rarely need to exist. The command center in this walkthrough is a persistent daemon that reads OpenTelemetry and JSONL logs to surface token spend, cache hit rate, MCP latency, skill costs, and security posture in real time, without injecting anything into Claude's working context. Skills running on demand and on schedule handle the execution layer; Cowork handles the communication layer. The resulting setup is lighter, cheaper to run, and actually answers the question most power users care about: where is the money going and is the system working efficiently.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:42
01 · Contrarian take: mission controls are overkill
Most YouTube mission controls add a seven-layer microservice that introduces context bloat without business value.
01:43 – 04:34
02 · Dashboard tour: observability layer
Live sessions panel, posture scores (security + context audits), token usage by model, cache hit rate — all fed from OTEL and JSONL logs.
04:35 – 09:22
03 · Task queue, scheduling, and Telegram approvals
Schedule creation with cron, ad hoc one-shot vs interactive task queue, model selection per skill, requires-approval gate linked to Telegram.
09:23 – 10:16
04 · Activity and MCP latency panel
OTEL-sourced latency and error rate for every tool type. WebFetch at 4s avg and 10% error rate signals a skill hitting access-denied walls.
10:17 – 12:05
05 · Token consumption deep-dive
Per-skill activation counts and total tokens over 24h. AI News Monitor at 32M tokens triggered an immediate audit and simplification.
12:06 – 14:58
06 · Skills & MCP panel
MCP cost and latency per server, skill cost-per-run rankings, context health score, full skills registry across all environments.
14:59 – 15:54
07 · Build your own — free prompt
Free prompt in description: paste into plan mode, Claude reads the latest OTEL and JSONL docs, then builds the same dashboard for your environment.
Lines worth screenshotting.
- Mission control dashboards that spawn named agents to run tasks are adding a seven-layer microservice to a problem that a scheduled skill already solves.
- The real value of an AI command center is observability — knowing what your AI is doing, what it costs, and where it is failing.
- OpenTelemetry is now available on Max and Pro plans, which means you can build real-time dashboards on token spend, cache hit rate, and MCP latency without enterprise access.
- A skill that used 32 million tokens in 23 sessions signals a badly designed workflow — observability surfaces these before they become expensive habits.
- Requiring human approval via Telegram before an agent executes a task is a practical middle ground between full autonomy and constant babysitting.
- MCP tool calls inside large skill chains pollute the agent's context and slow the system — code execution is often faster and cleaner.
- Notion's MCP update and search operations are among the slowest tool calls in a Claude environment; switching to local storage eliminates that latency entirely.
- If you can see that a skill fails consistently at one tool call, you can fix that one call instead of debugging the entire workflow.
- Knowing the cost per skill run — not just accumulated spend — is what lets you identify which workflows are worth optimizing.
- The entire purpose of an AI operating system is to execute on goals, not to build elaborate systems for managing the systems that manage the goals.
- Cache hit rate is one of the most leveraged metrics in a Claude environment: maximizing it directly reduces how much of your usage limit each task consumes.
Build the dashboard that tells you what Claude is actually doing.
Steal this architecture
Skip the agentic theater — the only mission control worth building is the one that shows you where your tokens go.
- Hook into OTEL (now on Max/Pro) + JSONL logs as your data layer — this is the same source that feeds Claude Code's built-in dashboard.
- Lead with a posture panel: security audit + context efficiency score. These two never go stale and they catch expensive problems early.
- Add token spend and cache hit rate as top-of-fold KPIs — these are the two numbers that change your behavior fastest.
- Treat the task queue as a sidebar, not the hero. Schedule everything predictable; only queue truly ad hoc tasks.
- Wire a Telegram approval gate for any task that touches something sensitive — human-in-the-loop from your phone, no desk required.
- Assign the cheapest model that works for each skill. Sonnet is the default; Opus is the exception.
- Steal the free prompt from his Google Drive and run it in plan mode — Claude reads the latest otel docs and builds the whole thing for your environment.
Terms worth knowing.
- OpenTelemetry (OTEL)
- An open-source observability framework that collects and exports metrics, logs, and traces from software systems, enabling developers to monitor performance and diagnose issues across distributed services.
- JSONL logs
- A log file format where each line is a separate JSON object — used by Claude Code to record every tool call, prompt, and response, making the data easy to parse programmatically.
- Observability
- The practice of instrumenting a system so its internal state can be inferred from its outputs — in this context, knowing exactly what an AI agent is doing, how much it costs, and where it fails.
- Daemon (persistent)
- A background process that runs continuously on a computer without user interaction, monitoring for events or conditions and responding to them automatically — here used to watch AI agent activity in real time.
- Cache hit rate
- The percentage of AI API requests that are served from a previously cached response rather than re-computing, which lowers cost and speeds up response time on Anthropic's platform.
- MCP (Model Context Protocol)
- A standardized protocol for connecting AI models to external tools, APIs, and data sources, allowing the AI to take actions like reading files, calling APIs, or controlling applications.
- MCP poisoning
- A security attack where a malicious or compromised MCP tool injects harmful instructions into an AI agent's context, potentially causing it to take unintended or dangerous actions.
- Context bloat
- The accumulation of unnecessary information in an AI model's active context window, which wastes tokens, slows responses, and can degrade output quality by diluting relevant signals.
- Human in the loop
- A workflow design where a human must review and approve an AI's proposed action before it executes, adding a safety checkpoint for high-stakes or irreversible tasks.
- Event-driven decision
- A system design pattern where an action is triggered automatically in response to a specific event (such as a task failure or threshold breach) rather than on a fixed schedule or manual request.
- Token usage
- The number of text tokens processed by an AI model in a given session or time period, which directly determines the cost when using a pay-as-you-go API or how quickly a subscription usage limit is consumed.
Things they pointed at.
00:53toolCowork (Anthropic)
02:15toolOpenTelemetry for Claude Code
07:34toolTelegram approval gate integration
06:59toolGamma AI deck generator
12:10toolNotion MCP
13:10toolObsidian local alternative to Notion
Lines you could clip.
00:30
“You do not need named agents to go out there and do work for you, especially if you are using Anthropic's ecosystem.”
08:50
“There is no crazy agentic layer with Pikachu pictures drawn and Tamagotchi figures and stuff like that. You don't need that as a business.”
14:53
“What does it actually do from a business perspective? Exactly. Just my maid vacuuming the lounge.”
01:21
“The goal of whatever you're doing in life and business is to execute on your tasks with AI, not introduce all of these other systems that just complicate it.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
analogy
00:00So you're pananthropic $200 a month for Claude, you have no idea what it's actually doing under the hood. In this video, I'll show you what a Claude command center looks like, why you don't need most mission controls you see on YouTube, and I'll drop you a prompt to build your own in the description below. Let's get into it.
00:13Submission control is a really interesting concept to me mostly because I think it is completely unnecessary for what people out there on YouTube are currently building it for. While they're technically super impressive from the business use case perspective, all they're doing is adding to the context bloat problem.
00:27They're introducing a seven layer microservice that absolutely doesn't need to exist. You do not need named agents to go out there and do work for you, especially if you are using Anthropic's ecosystem.
00:37It's way more efficient just to use skills and have them running on demand on schedules and things like that. More importantly, if you wanna have this front layer where you can communicate back and forth with an agent, that's why they built Cowork.
00:49It is literally the sole purpose of this thing, and it can do 98%, if not more, of what you can do with your AI operating system in an IDE inside this little graphical user interface that's much better for business people out there. You can check out the video on the screen right now if you wanna know how to build your own AI operating system inside Cowork itself.
01:07For this video, I wanna focus on the contrarian approach that for me, my command center is observability first because that's where I think most of the value in actually having this thing comes into play. And then, of course, inside here, we have got some kind of task functionality because there are a few edge cases where we would actually want to launch agents from inside this panel and we'll get there in just a second.
01:27But please, everybody, take a step back. The goal of whatever you're doing in life and business is to execute on your tasks with AI, not introduce all of these other systems that just complicate it. Skills exist for a reason, and we're gonna exploit them as much as we can inside our environment.
01:42Great. And now that all the boring practicality stuff is out of way, we can get into this video. So our command center is to handle in flight sessions, our task queue, and our schedules all in one place over here, and we can go through it layer by layer.
01:54More importantly, this thing is a persistent daemon, so it is always running locally on my system. It will go out there and find things that it needs to do, make sure my schedules are running as they should be, and finally, it will report on literally anything that we can get our hands on.
02:07When we're looking at what Anthropic gives us, it gives us JSONL logs, which is just tracking everything that Claude and Claude co worker use, And then also, we have OpenTelemetry now, which they finally released to people on the Max and Pro plans. Previously, it was only for enterprise people and that's how you see this shiny little mediocre dashboard inside Claude code in the GUI.
02:26This dashboard over here is fed partially from otel, but that's what we can exploit massively over here because there is a ton of documentation. So we can build a lot of real time info. As you can see, our dispatcher is running and everything is working as it should be.
02:38We have no live sessions running currently. We'll kick one off in just a second. But posture is a really important thing to have on our observability dashboard because it tells us two of the biggest problems that you will have in your business.
02:49One of them being security. Now, I have another video on this and exactly what this skill does, but essentially it's a skill that lives in our environment and it runs out there doing an audit finding things like opportunities for MCP poisoning, various other MCP attacks, skill problems, various settings that we have in our environment that we might want to change because it can be exploited.
03:06So we could run that task from this dashboard and you should be running it regularly, probably on a schedule. But then if it found anything, you would be able to see the entire report over here so that you could act on it. Now me having worked in cyber security for twelve years, you can see that I always keep my environment completely not up to date and in the worst possible practice.
03:24But that's because it's my dev environment and I don't really care. On the right hand side over here, we have context. And this is solving the context bloat problem that everybody has been facing.
03:32Again, I have another video on this as well. Anything that I mention here will be in the description below. But what this skill is doing is it's running through everything in your environment where you're being drastically inefficient with the way that you're handling context.
03:42With the goal being to turn all of that around by looking at this report to figure out what you can do to be better at using context within your environment. So these two things are never static. You're not going to run the skill once and yes, we're set for the rest of our lives now.
03:55Because AI evolves, the entire landscape evolves constantly. These two things will need to be run on regular intervals to make sure that you are doing the best practice at the time of whatever it is that is happening. So for me, these are the two most important things that we are currently trying to solve now.
04:09Then next up, we have a quick panel on token usage, and that's just to give us an overview of the number of tokens that we've used by model over the last x number of days. This ties in with another panel that we're gonna look in just a little bit.
04:21As we scroll down, we see the cache hit rate. This is super important. You wanna make sure that you're hitting Anthropix cache servers as much as possible because, obviously, that will save you some of your usage limit.
04:30These panels over here, they are important, but I'm not gonna go into them because they're not important to this video. What I do wanna focus on next is this mission control and this is what a lot of people are doing now because they're trying to piggyback off of what paper clip and Hermes and whatever those things are that go out there and work autonomously for you.
04:46So you can build that functionality for sure, but you have to think about why you're building that functionality. For me, if I'm looking at doing something like researching leads or things that I know are predictable, I don't need mission control to that.
04:59I don't need a task board. I can just set up a scheduled task. There is no need to have this little agent window running away and doing things.
05:06If you're in co work, it's easier than ever. You can just set up a scheduled task right over here. If you're in here, you could just set up a cron schedule which you could do straight from your IDE or in this case, we obviously built in the capability to do that down here.
05:19So before I'm about to come into my mission control and do anything, I'm going to be planning my business life out and figure out what needs to run on a schedule and what I might want to do on an ad hoc basis and make sure I have concrete reasons behind both of those things. Then once I've figured that out, I'm going to go into my environment wherever that may be and I'm going to start with the stuff that I can schedule so that everything is in place running on autopilot already.
05:41Now, if I wasn't using Cowork and for whatever reason I wanted to use this mission control, I would be able to click over here and it's pretty much exactly what Cowork has. We've put in a name so we could say morning brief and spell it like a weirdo. And then down here, we can just set the time.
05:54I want this to run at 09:00 every single day of the week. Then it sets up our cron schedule. We can give a task title and any details.
06:01This is obviously where we need to give it the name of the skill. In this case, it would be the morning brief skill because this is gonna be the command that gets sent to Claude. If that wasn't clear enough, you can obviously come down to your list of skills that we have mapped from our environment and you could select it to go and run the thing based on there and it could be enabled by default.
06:17Then we would just hit run and we would have it as a list inside our scheduled tasks over here running away on its cron schedule and doing whatever it needs to do. Then once I've done that, it brings us onto the case of okay, cool. Now I have some ad hoc tasks that I need to run.
06:30So we might then come up to our queue task and again, very similar window. We have separate options over here. So we can either have an interactive session where we can have a back and forth with the agent inside this little panel over here or we do a one shot which is basically just firing a skill that we know works making it happen once.
06:47Make me a Gamma Deck on Claude computer use. The MD file is in my deliverables folder. Something that also is important to note here is that by default it's going to be selecting it from the skill.
06:57If you are creating skills, one of the most efficient things that you can do is obviously assign the model. This again helps you with all of that context bloat. You don't want everything running with Opus just because Opus is the best.
07:07Many tasks don't actually need this. For a complex task like creating a Gamma Deck, it might sound like you need Opus but you don't.
07:14Unless this thing is gonna be writing and doing a bunch of other things, you can easily get away with Sonnet because most of the AI work is done by the gamma agent itself, obviously. So we can get away with Sonnet for this and that's exactly what we're going to do.
07:26If I had many tasks running at the same time, I could set a priority to make sure which one goes next after the other based on that little setting over there. And also you can have requires approval. This is important if you're doing things ad hoc where you need a human in the loop before we do that and I've built a panel just for that.
07:42So what I'm gonna do is I'm gonna hit requires approval and I'm gonna queue this task. Now, what this thing does is it's also linked to my cell phone via telegram.
07:51So while this thing is waiting for approval, say something kicked off while I had to suddenly nip out for something, I could then come on over to my telegram agent over here and guess you can't see it on camera, but there you go. It's asking for approval. All I need to do is hit approve.
08:05That then changes on screen as you can see and the agent is now gonna start running through this thing and do the task that I asked it to do. That's when we scroll back up here just to make sure everything's working as it should And very, very soon, this thing's going to populate a live session based on the agent task that it's got ahead of it.
08:21So it's moved into running and you can see over here that we've got two live sessions. One is the router from the Haiku agent that routes tasks between everything. And then this one is just an interactive session of what's actually happening from the Sonnet agent over there.
08:33So it's going out and searching in real time. This is just a live tale with GREP, so it's nothing really crazy over here. But it's finding the relevant files, reading them, and then it's gonna write the PSP or in this case, it's going to use what I've already got there, which is the framework that I wrote for that video.
08:47So I'm gonna send it off to Gamma and do what it needs to do. And you can see over here that this thing went and found my PSP framework that I wrote for the video. So it's going to use this and it's gonna send it off to our Gamma agent.
08:57And you can see that's why it's much better to use something like this. There is no crazy agentic layer with Pikachu pictures drawn and Tamagotchi figures and stuff like that. You don't need that as a business.
09:07You just need to make money or execute on your goals. That's the whole point of this. Everything else is just a mess that you are one day going to have to manage or troubleshoot or deal with.
09:15You don't need that crap. Just use co work. And with that micro rant out of the way, we're going to get into some of the more valuable things in here, which is understanding what's actually happening in-depth in our environment because this is how we refine, save money, and make the work that we do way more efficient.
09:31So this dashboard is all about activity that's been going on in your environment. My favorite part of this is understanding the latency and error rate of all the tools that Claude is actually running into in my environment, specifically with MCP and APIs as well.
09:43That's going to help you understand where things could be going wrong as a part of your skills. For instance, in web fetch, if we constantly have a massive error rate, that could mean that one of our skills is constantly trying to access something that it can't. One of the most popular things is where it gets an access denied problem, in which case we could go and address that.
10:00But obviously, we would want to make sure with more information first. And that's where we get into skills over here and understanding how often they run and how much they cost and things like that. So activations is really important because it shows us how many times over the last twenty four hours our skills have been activated.
10:16So we get to see what we use most often, which obviously forms part of this picture. But then as we dive down further, we can see the frequency associated with the consumption. So our AI news monitor over here, ran it over 23 sessions.
10:28You can see it used 32,000,000 tokens. So this was something I addressed earlier because as soon as I saw that, I was like, why the hell is my news monitor using so many tokens?
10:37So understanding things like this help you become more efficient as a business and mostly is how much you're spending with AI. Because if this stuff was actually going out through the API and not on my subscription, it would be such a waste of money.
10:49This process ended up being so massively simplified with the exact same result. I'm gonna see a massive change in this.
10:56Next up, I obviously have to do ExcaliDraw. That's generally hungry because it draws lots and lots of slides. But the idea here is that you would be able to go through this and audit your environment to understand how to make it more efficient.
11:05We can then obviously see if there were any failures. Thankfully for me, I had absolutely none. And we can also come and have a look at any previous sessions that were run.
11:13So this is the one that we just ran in the other window over here. You can see that this one has now completed. So it left that queue and it's come across into here where the recent sessions that have run over the last don't know how many days, but we've got 19 here displaying just 10 of them.
11:27So this was the task that ran. We got our session ID, the model that was used, and how long this thing ran for. Pretty straightforward.
11:33It wasn't doing most of the work. Again, it was set off by Gamma. But the idea here is that you would be able to come down here and filter down to see if any of yours have failed.
11:41Something you could then do based off of this is obviously have event driven decisions. So if something failed, you could get alerted either on your phone if it was that important or you could get alerted by something else anywhere that goes into another system so that system can then respond to it, maybe even redo the workflow.
11:56Whatever it is that you needed to respond to could happen as a result of this. That's again why observability is so important. Making event driven decisions proactively and in some cases reactively, but at least without the human having to sit there and worry about it in an anxious state.
12:10This is very important if you're setting up an AI operating system for your clients. You wanna know that their things are working. So if something does go down or something fails, they're not going to know about it unless you have set up something like this for you to monitor them or they have someone on-site obviously.
12:23Then last but not least, we go over skills and MCP in detail. So for me, I don't mind using MCP that much, but it is really hungry at certain times depending on the task that you're doing. If you're doing this as part of a larger system where there are constant back and forths, it can really pollute whatever it is that your AI is working on.
12:40So this kind of helps with that. It helps us understand how much our tool runs are costing us with MCP.
12:46It tells us how slow everything is and the slowest parts of these tools. So for me working in Notion, update pages really slow, create database is slow, search is slow. There are ways around using MCP directly.
12:59We can use code execution, which is another layer that I will discuss in another video because it deserves its own deep dive. Point is there's lots of ways around these problems that we find, but unless we know about them, we can't solve them. So if you're using Notion heavily and you don't really need the visual layer, you just only know it as a place to store documents, you might want to switch to Obsidian because then everything's local and all of the other benefits that you get with that.
13:21For me, I prefer a visual layer when I'm working, is why I use Notion And this helps me understand how performant my system is. For me, this kind of latency is minimal and even the token usage here is completely minimal. So I don't care.
13:32There's no way you can convince me to change that based on this. But it is all valuable information. Obviously, we want to understand our skill cost per run as well, so we've got that included in here.
13:41This morning brief is more than the AI News Monitor because this is something that I'm currently working on in three environments running through multiple systems, so these metrics are a bit skewed. But the idea here is that this will obviously tell you what your most expensive skill is per run, not the accumulated one like we had in the other view.
13:57The idea being that you can assess all of this and then figure out how you can make these skills more performant because you wouldn't want them wasting as much tokens as they do. And then last but not least, we have the context health over here, which just tells you, again, based on the video that I had on context engineering and such things, how you could be better inside your environment using context overall in various places.
14:16And on the right, we just have a skills registry that shows us every single skill in all of our environments with a breakdown of what they do. This is just for a user perspective, so you have an audit of whatever's going on in your environment.
14:27Good to keep track of these, you can get rid of them whenever you don't need them, obviously. So from this perspective of the video, I think this is where the value of a mission control comes in. Realistically, co work again is just there for people who don't want to use an IDE.
14:39So using any of that other stuff is just fluff, guys. It is a distraction. It's pretty.
14:43It looks great and sure the people who put the time and effort into that, it is amazing, really smart, doing crazy things. But what does it actually do from a business perspective? Exactly.
14:54Just my maid vacuuming the lounge. That's the only sound we hear resonating when that answer comes up.
14:59But I do want to give you guys the capability to go and build this thing for yourself. So I've written you a prompt based off of what I built and this thing will go out there for your environment, read all the latest docs that it needs to and then pull down the same information. You can obviously tailor this to the way that you want it, specifically taking out things or including things.
15:14Again, if you don't need that mission control functionality, just completely get rid of it. All you have to do is copy this prompt, paste it in there, flip it over to plan mode, of course. You don't just wanna yolo your way through this.
15:24I have told this thing to do some of the latest research for the hotel logs and JSONL just so that it understands what it needs to do. Then you would hit enter and this thing will go out there and do that and probably ask you a few questions along the way. And that's really it in a nutshell.
15:36You can add or subtract as much functionality as you want. Don't think most of you are gonna need that Mission Control there. But if you do, you can obviously just ask this thing to go and add that.
15:44Other than that, that pretty much wraps it up for this video. So thanks very much for watching, guys. Leave some comments below, I'll get back to you as soon as possible.
15:49Otherwise, check out the videos on the screen now. They'll definitely help you in your journey. I'll see you in the next one.
The Hook
The bait, then the rug-pull.
You hand Anthropic $200 a month and Claude disappears into a black box. Mansel Scheffel built a persistent local daemon that drags every token, every tool call, and every failed session back into the light.
Named ideas worth stealing.
01:43model
Observability-First Command Center
- Live sessions
- Posture (security + context audits)
- Token usage by model
- Cache hit rate
- Task queue (edge-case only)
- Activity / MCP latency
- Skills & MCP cost panel
A persistent local daemon that reads OTEL + JSONL logs and surfaces operational data rather than launching agents.
Steal forAnyone running Claude Code at scale who wants to stop flying blind on token spend and MCP reliability
04:57concept
Schedule-First, Mission Control-Last
Plan your AI work first; anything predictable goes on a schedule. Mission control is only for genuine edge cases.
Steal forFramework for deciding when to build a UI vs just writing a cron skill
06:55concept
Model Selection Per Skill
Assign the cheapest model that can complete each skill. Sonnet is the default; Opus is the exception.
Steal forCost reduction framework for AI operating systems
How they asked for the click.
VERBAL ASK
14:59link
“I've written you a prompt based off of what I built — all you have to do is copy this prompt, paste it in there, flip it over to plan mode.”
Soft and practical — no hard sell. Shows the prompt live in Claude Code and points to Google Drive link in description. Effective because it delivers the promised artifact.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
