Latest / AI Fire Daily / #663 Neil: 5 Claude Code Tools I Tested for Cleaner, Faster Work

Transcript

#663 Neil: 5 Claude Code Tools I Tested for Cleaner, Faster Work · AI Fire Daily

• 0:00
  You're staring at your terminal right now. And
• 0:03
  all you did was ask Cloud Code for a simple submit
• 0:05
  button. Yeah, just one basic button. Right. But
• 0:08
  instead of like five lines of code, you get five
• 0:10
  pages of text. Oh, it's the worst. Hundreds of
• 0:13
  lines of just useless error log scrolling by.
• 0:15
  It's pure, untiltered chaos on your screen. It
• 0:18
  really is overwhelming when that happens. I mean,
• 0:20
  the AI just runs completely out of control sometimes.
• 0:23
  Welcome to this deep dive into optimizing cloud
• 0:26
  code. Today, we are looking at five very specific
• 0:29
  tools. And they're completely free to use right
• 0:31
  now. Yeah, they act as essential filters for
• 0:34
  your daily workflow. So they help you write much
• 0:36
  cleaner code. Right. And they save you valuable
• 0:39
  tokens on your bill. Exactly. And they fundamentally
• 0:42
  simplify that initial project planning phase.
• 0:45
  Which is huge. Because these tools, they solve
• 0:47
  very different problems than your workspace.
• 0:49
  Yeah. But they all share this one core philosophy.
• 0:53
  They are built to constrain the AI's worst habits.
• 0:56
  I will be completely honest with you right now.
• 0:58
  I still wrestle with prompt drift myself. We
• 1:01
  all do. I mean, it's a very common struggle today.
• 1:04
  You ask for one thing, and the AI pivots. Right.
• 1:07
  Next thing you know, you're building an entire
• 1:09
  operating system. Exactly. And, you know, every
• 1:12
  project really needs to start with a solid plan.
• 1:14
  Or at least it absolutely should. Definitely.
• 1:16
  But reading endless AI -generated markdown files
• 1:19
  is exhausting. You just kind of lose the big
• 1:22
  picture so quickly. Well, human brains aren't
• 1:24
  really optimized for reading raw formatting.
• 1:27
  No, not at all. We don't process like asterisks
• 1:30
  and hashtags very well. We process visual information
• 1:33
  much faster. Right. So we need to tame the planning
• 1:36
  phase first. And that's where an open source
• 1:39
  tool called Lavish really helps. Yeah, Lavish
• 1:41
  is great. It fundamentally changes how you view
• 1:44
  your project plans. It does. It moves you away
• 1:47
  from those endless scrolling text files. Exactly.
• 1:50
  It actually turns long project plans into interactive
• 1:52
  HTML pages. Let's look at the specific source
• 1:55
  example we have today. OK. The developer was
• 1:58
  building a basic task management app. That's
• 2:01
  a super standard project for most developers.
• 2:02
  It's a really great baseline for testing these
• 2:04
  tools. Right. So they asked Claude to create
• 2:07
  a detailed project plan. They wanted main features,
• 2:10
  page layouts, development steps. And normally
• 2:13
  Claude would just spit out massive text files
• 2:15
  for that. Yeah, it would just be this giant wall
• 2:17
  of dense markdown. Right, and your eyes just
• 2:20
  glaze over instantly. But Lavish intercepts that
• 2:23
  raw text generation. Oh, wow. Yeah, it generated
• 2:26
  actual visual wireframes for the entire app instead.
• 2:29
  So you could clearly see the workspace and the
• 2:31
  task details. Exactly. Think about looking at
• 2:33
  a messy, text -heavy blueprint. It's very hard
• 2:36
  to visualize the final product. Yeah, totally.
• 2:39
  Now imagine turning that into a 3D model. You
• 2:41
  can actually walk through that model visually.
• 2:43
  That is exactly what Lavish does for code planning.
• 2:46
  It makes the abstract plan feel very real. And
• 2:49
  I imagine you can spot design flaws much earlier.
• 2:52
  Oh, absolutely. And it isn't just a static picture
• 2:55
  on your screen either. Wait, really? Yeah, you
• 2:57
  can actually interact with this generated HTML
• 3:00
  page. OK, so how does that work? Well, you can
• 3:03
  click on a very specific visual section. So let's
• 3:06
  say the dashboard layout looks entirely too crowded.
• 3:09
  Right. You just click that specific crowded dashboard
• 3:12
  section. Then you leave a comment in the conversation
• 3:15
  panel. And you send that feedback directly back
• 3:17
  to Claude. Exactly. It updates the visual plan
• 3:20
  before any actual coding even starts. Catching
• 3:24
  those confusing parts early saves so much time.
• 3:26
  But I'm curious, how does this handle the setup
• 3:29
  process? Like, without making you leave the terminal?
• 3:31
  Oh, it's super smooth. You literally just ask
• 3:34
  Claude to install it directly from GitHub, reviewing
• 3:37
  the command before approving. So Claude installs
• 3:40
  its own visual upgrade directly from the repository?
• 3:43
  Brilliant. Yeah. It keeps you entirely focused
• 3:46
  on the actual work. You never break your flow
• 3:48
  state to manage plugins. That's fascinating.
• 3:51
  So, okay, you've got this beautiful 3D model
• 3:53
  of your plan. You hand it over to Claude to actually
• 3:55
  build. Right. But if you've used AI lately, you
• 3:58
  know its worst habit. Oh, yeah. desperately tries
• 4:01
  to show off. It really does. It always assumes
• 4:03
  you want like a massive enterprise level solution.
• 4:06
  You ask for a button, it builds a massive framework.
• 4:09
  Exactly. Sometimes you really just want a simple
• 4:12
  static page. And this is where a tool called
• 4:15
  Ponytail enters the chat. Right. Ponytail. It
• 4:18
  works by wrapping your prompts in strict constraints.
• 4:22
  It essentially tells Claude to stop over -engineering
• 4:24
  everything. It actively forces Claude to use
• 4:27
  much simpler solutions, right? Yes. It forbids
• 4:30
  Cloud from using unnecessary external libraries
• 4:32
  entirely. It literally limits the scope of the
• 4:35
  context window. Let's look at the specific test
• 4:37
  from our source today. Sure. The assigned task
• 4:40
  was creating a simple HTML form. Just a basic
• 4:42
  form. Right. It needed a date picker and a safe
• 4:45
  button. Right. That is Web Development 101 stuff.
• 4:48
  Absolutely. So, Cloud initially built this basic
• 4:51
  form using 34 lines. Yeah. I mean, it worked,
• 4:55
  but it was bloated with totally unnecessary JavaScript.
• 4:58
  Then they asked Claude to review its own work.
• 5:00
  They told it to use native HTML features instead.
• 5:03
  And Claude realized something really important
• 5:05
  during that specific review process. What was
• 5:08
  that? Built -in HTML validation could easily
• 5:11
  handle the empty dates. So it didn't actually
• 5:13
  need all that extra JavaScript? Not at all. The
• 5:16
  extra JavaScript was entirely stripped away.
• 5:18
  Wow. And the result reduced the final code down
• 5:21
  to 27 lines. Yeah. That's a solid 21 % reduction
• 5:25
  in total code. It's huge. The ultimate irony
• 5:27
  of AI coding is right here, isn't it? We are
• 5:29
  using the most advanced technology in human history,
• 5:32
  and we have to build tools to restrain it. We're
• 5:35
  forcing it to write code like it's 1999. Well,
• 5:38
  because boring HTML is actually bulletproof,
• 5:40
  it just works without constant maintenance. Does
• 5:43
  relying on native HTML features actually make
• 5:46
  the code more robust or just shorter? It makes
• 5:49
  it shorter and removes external dependencies,
• 5:51
  which naturally reduces the surface area for
• 5:53
  bugs. Fewer dependencies mean less code to break.
• 5:57
  Makes perfect sense. Totally. Simple code is
• 6:01
  always easier to maintain long term. Every extra
• 6:03
  library is a future vulnerability waiting to
• 6:06
  happen. Right. So the code is finally clean and
• 6:09
  highly optimized. You have a solid form with
• 6:12
  zero unnecessary bloat. Yes. But when you test
• 6:15
  that newly written code, things happen. Testing
• 6:20
  is where the real chaos usually starts. The terminal
• 6:23
  spits out massive, unreadable error logs. And
• 6:27
  Claude obediently reads every single line of
• 6:29
  that output. Which means it's rapidly eating
• 6:32
  up all your tokens. Tokens are just tiny chunks
• 6:35
  of words that AI reads and writes. Exactly. And
• 6:38
  those tiny chunks cost you real money, eventually.
• 6:42
  Every time Claude reads a log, you get billed.
• 6:45
  A busy terminal can generate thousands of lines
• 6:47
  instantly. Claude reads your whole directory
• 6:50
  just to find one file. It's so inefficient. This
• 6:53
  brings us to a tool called RTK. Right, which
• 6:56
  stands for the Rust Token Killer Tool. RTK acts
• 7:00
  as a strict, ruthless filter for your terminal.
• 7:04
  Yeah, it filters and compresses terminal output
• 7:06
  before Claude processes it. It acts like a bouncer
• 7:09
  for your context window. I love that analogy.
• 7:12
  It shortens file lists and groups similar errors
• 7:14
  together. It stops Claude from reading the same
• 7:17
  repeated error messages over and over. Take a
• 7:21
  standard terminal command as a great example.
• 7:23
  Let's examine the specific source test mentioned
• 7:25
  here. They ran the basic ls -la command through
• 7:28
  bash. Right. And normally, Claude reads every
• 7:31
  single line of that directory output. Yeah, it
• 7:34
  eats your context window alive with formatting
• 7:36
  data. But RTK compresses that output dramatically
• 7:40
  before Claude even sees it. RTK saved 971 tokens
• 7:44
  on that single terminal command. Unbelievable.
• 7:47
  That is an 80 .1 % reduction for that output.
• 7:50
  Whoa, imagine scaling that token saving to a
• 7:53
  billion queries. The financial efficiency gains
• 7:55
  would be absolutely massive at scale. Enterprise
• 7:58
  teams could save thousands of dollars a month.
• 8:00
  But we have to mention a quick caveat here. Oh,
• 8:03
  right. RTK currently works extremely well with
• 8:06
  the bash terminal. Yeah, that's a very important
• 8:08
  detail to note. Automatic filtering for PowerShell
• 8:11
  was not verified in the tests. So Windows users
• 8:14
  might need to do some manual tweaking. Exactly.
• 8:17
  Does this 80 % reduction apply to the entire
• 8:20
  Claude bill? No. It only reduces the terminal
• 8:23
  output cost. Your actual conversation prompts
• 8:26
  still use their normal tokens. Right. It cuts
• 8:28
  the terminal noise, but your chat history still
• 8:30
  costs tokens. Correct. It's a targeted fix for
• 8:34
  terminal spam specifically. We're going to take
• 8:36
  a very brief pause here. Midroll sponsor read.
• 8:40
  And we are back. Welcome back to our deep dive
• 8:43
  on Claude code. So we have successfully silenced
• 8:47
  the noisy terminal output. The coding environment
• 8:49
  is much quieter and cleaner now. But Claude itself
• 8:52
  is still way too chatty sometimes. Like if you
• 8:55
  ask for a quick code fix, you just want the code.
• 8:58
  You don't need a philosophical essay on JavaScript
• 9:01
  history. Exactly. It's like a junior developer
• 9:03
  trying to prove themselves to you. That is where
• 9:06
  the Caveman plugin becomes incredibly useful.
• 9:08
  Caveman actively cuts out all those unnecessary
• 9:10
  text explanations. Yeah, and it has a few different
• 9:13
  operational modes you can use. You can choose
• 9:16
  light, full, ultra, and normal modes. Let's look
• 9:20
  at the test from the source again. The user had
• 9:22
  a basic JavaScript undefined error. Right, and
• 9:25
  they tested it using the full caveman mode setting.
• 9:28
  The full mode gave very direct code fixes immediately,
• 9:31
  but it felt slightly unnatural for absolute programming
• 9:34
  beginners. It was almost too blunt. It completely
• 9:37
  lacked helpful learning context. So you don't
• 9:39
  really know why it fixed it. Right. Right. That's
• 9:42
  why the light mode is generally recommended for
• 9:44
  everyday use. It removes filler while keeping
• 9:47
  important learning details intact. Exactly. Now
• 9:50
  let's contrast the data on the actual token savings
• 9:52
  here. Because this is where the numbers get very
• 9:55
  interesting. The developers claim a massive 65
• 9:58
  % token reduction, but independent testing paints
• 10:01
  a very different picture. Much different. JetBrains
• 10:04
  tested this across 86 different coding tasks.
• 10:07
  They found only an 8 .5 % reduction in tokens.
• 10:11
  That is a massive discrepancy in the expected
• 10:13
  financial savings. Only 8 .5%. Honestly, at that
• 10:17
  point, is it even worth installing the plugin?
• 10:19
  It barely makes a dent in the monthly bill. That's
• 10:22
  a completely fair question. And here's what is
• 10:24
  actually happening under the hood. Let's unpack
• 10:26
  the mechanics of this discrepancy. Well, shorter
• 10:29
  responses definitely save you on output tokens.
• 10:32
  But Caveman works by injecting hidden instructions
• 10:36
  into your prompt. Right, and telling it to be
• 10:38
  quiet costs input tokens. Exactly. The plugin's
• 10:41
  hidden instructions consume your input tokens.
• 10:43
  So you save on the back end, but pay on the front
• 10:46
  end. There's also a strange UI quirk to mention,
• 10:50
  isn't there? Yeah, there is. The status bar incorrectly
• 10:53
  showed the light mode active. Even when the config
• 10:56
  file confirmed full mode was active, you really
• 10:58
  have to double check your actual settings very
• 11:00
  carefully. If the plugin itself adds instructions
• 11:03
  behind the scenes, does it actually save money?
• 11:06
  Not necessarily. Shorter responses save output
• 11:09
  tokens, but the plugin's hidden instructions
• 11:11
  consume input tokens. So you're trading input
• 11:15
  tokens for output tokens. The savings aren't
• 11:18
  guaranteed. You really have to weigh the speed
• 11:20
  against the hidden costs. The real value might
• 11:22
  just be less reading for you. We've completely
• 11:25
  streamlined the entire coding environment now.
• 11:28
  Visuals, code, terminal, and chat are all locked
• 11:31
  down. Yes. The entire system is running lean,
• 11:34
  fast, and quiet. You have essentially built a
• 11:37
  custom IDE for your AI. Now, how do we apply
• 11:40
  this highly optimized AI? Like, how does it help
• 11:42
  the rest of our daily operations? We aren't just
• 11:44
  coding all day long. Right. And Anthropic actually
• 11:47
  built a tool for this exact purpose. It bridges
• 11:49
  the gap between coding and business operations.
• 11:52
  Which is appropriately called the Small Business
• 11:54
  Plugin. Yes. This plugin offers ready -made workflows
• 11:57
  for routine daily tasks. So you don't have to
• 12:00
  write complex prompts from scratch every time.
• 12:02
  Right. You don't need to be a prompt engineer
• 12:04
  anymore. Anthropic knows business users need
• 12:07
  immediate practical utility now. They just want
• 12:09
  to ask a question and get answers. Exactly. And
• 12:13
  it includes some very specific business skills
• 12:15
  right out of the box. Let's walk through what
• 12:17
  these workflows actually do. There's business
• 12:19
  polls for quick overall performance overviews.
• 12:22
  Yeah, it gives you a nice snapshot of your daily
• 12:24
  metrics. Right. Then there's the grow pipeline
• 12:26
  for customer conversion tracking. The inbox manager
• 12:29
  helps you organize messages and vital follow
• 12:31
  ups. And the Inventory Planner helps you prepare
• 12:34
  your restocking decisions. It's kind of like
• 12:36
  stacking Lego blocks of data together. It literally
• 12:39
  is like having a team of specialized digital
• 12:41
  assistants. They handle the repetitive administrative
• 12:44
  tasks so you can focus. Exactly. So you can stay
• 12:47
  in your coding flow state longer. Can it actually
• 12:50
  read live sales data, or do I have to spoon feed
• 12:53
  it numbers? You can feed it manually, but to
• 12:55
  get live automated reports, you have to connect
• 12:58
  to your specific business apps. It needs access
• 13:01
  to your actual apps to be fully automated. Okay,
• 13:04
  got it. Yeah, and security and access permissions
• 13:06
  are absolutely critical for that step. You have
• 13:09
  to trust the AI with your live data. Let's synthesize
• 13:13
  the main takeaway from all this today. AI is
• 13:16
  obviously an incredibly powerful tool for us.
• 13:18
  Oh, without a doubt. But its default state is
• 13:20
  chaotic over delivery of information. It constantly
• 13:23
  wants to give you everything all at once. It
• 13:26
  wants to prove how smart it is constantly. The
• 13:29
  real skill in using cloud code isn't just writing
• 13:31
  prompts. Writing good prompts is really just
• 13:33
  the basic entry fee today. Yeah, everyone knows
• 13:35
  how to ask an LLM a question now. That's no longer
• 13:38
  a unique or highly valued skill. The real skill
• 13:42
  is using tools like lavish and ponytail. Right.
• 13:44
  It's using caveman to strategically constrain
• 13:47
  the AI output. You have to boot rigid guardrails
• 13:50
  on that mass of intelligence. You're basically
• 13:51
  building fences around a very smart system. And
• 13:54
  those small adjustments compound massively over
• 13:57
  a whole project lifecycle. They really do. Dropping
• 13:59
  from 34 to 27 lines of code seems completely
• 14:03
  minor at first. But across 10 ,000 lines of code,
• 14:06
  that's a huge difference. That's the difference
• 14:09
  between a clean app and a buggy mess. Saving
• 14:12
  a few tokens on one terminal command feels small.
• 14:15
  But over a month of heavy development, it saves
• 14:17
  hundreds of dollars. The efficiency gains are
• 14:20
  entirely found in the margins. We have a specific
• 14:23
  challenge for you to try this week. We want you
• 14:25
  to actually test this in your own workflow. Pick
• 14:28
  just one tool and see how it behaves for you.
• 14:31
  Install just one of these tools we discussed
• 14:32
  today. Try installing RTK or Caveman on your
• 14:35
  own machine. Then check your actual terminal
• 14:38
  logs and usage stats. See your own token savings
• 14:41
  in real time. Experience the quiet terminal for
• 14:44
  yourself. It's a game changer. I want to leave
• 14:48
  you with a final philosophical idea. This is
• 14:51
  the part that really makes you wonder about tomorrow.
• 14:53
  We are relying heavily on plugins to govern Claude
• 14:55
  today. We're building filters to control the
• 14:58
  main intelligence program. Or we're using secondary
• 15:01
  code just to manage the code generator. Exactly.
• 15:05
  So are we looking at a very strange future workflow?
• 15:08
  A future where our primary job isn't doing the
• 15:12
  actual work. We might just act as a high level
• 15:14
  manager to an entire ecosystem. An ecosystem
• 15:17
  of AIs that just critique and filter each other.
• 15:21
  We are just the organic supervisors of a digital
• 15:24
  assembly line. Something for you to mull over
• 15:26
  until next time.