u/Daniel_Janifar

Google dropped some agentic developer tools last week specifically for Android that cut token consumption by 70% and reportedly complete tasks 3x faster. The tooling includes new CLI skills and curated knowledge bases baked in for AI-assisted development. Worth a read if you haven't seen it yet.

What's interesting from a no-code workflow angle is the token efficiency framing. Most of us don't think about token cost when we're wiring up automations, but if you're running AI nodes at any real volume, it compounds fast. The Google release is a good reminder that how you structure your prompts and, how much context you're feeding into each step matters a lot, even on visual platforms. Tighter inputs, scoped knowledge, less fluff in the chain.

I've been applying that same logic to workflow builds lately, whether in n8n, Latenode, or wherever the client, stack lands, and trimming the context window on AI steps usually speeds things up noticeably without hurting output quality. The Android tools are developer-focused but the underlying principle translates pretty directly.

The CLI skills piece is also worth flagging for anyone building agent workflows that touch mobile or device-layer tasks. Google publishing official knowledge bases for this stuff means less hallucination risk on platform-specific calls, which has honestly been a pain point for a while.

[ Removed by Reddit on account of violating the content policy. ]

Been running a hook for about a week that forces Claude Code to use LSP instead of Grep for code navigation. Token usage dropped by roughly 80%. The logic is simple: Grep returns 20+ fuzzy matches and Claude reads 3–5 files semi-randomly to figure out which one it wanted — that's 1,500–2,500 tokens of context per file, gone. LSP returns one exact answer in ~600 tokens because it's the same protocol your IDE uses for "Go to Definition." Precise vs. probabilistic.

What I keep thinking about is how many other "defaults" inside agent tools are quietly expensive for the same reason — the tool reaches for a generic text-based approach when a structured one already exists and just isn't wired in. Grep vs. LSP is one example. I'd bet there are similar wins hiding in file system traversal, dependency graphs, API schema lookups, probably database queries too. The pattern seems to be: anywhere the model is doing fuzzy search over something that has a proper index, you're paying tokens for ambiguity you didn't need to pay for.

Three things I'd actually like to hear:

Has anyone found a similar swap in a different domain — replacing a generic tool call with a structured one and getting a big efficiency jump? What was the before/after?

For people running Claude Code seriously day to day, what other hooks or custom tools are quietly doing most of the work for you?

And a more speculative one: how much of the "agents are expensive in production" problem do you think is actually this — not model cost, but lazy defaults in the tooling layer around the model?

(Quick note on the hook itself: make sure Claude Code is on the latest version. Older builds handle hooks poorly and you'll waste an afternoon figuring out why it's not firing.)

Been thinking about this a lot lately. You see these models hitting crazy high scores on benchmarks and it's easy to assume they've basically "solved" language. But then you throw something culturally specific at them, or code-mixed text, or anything that relies on local context, and they kind of fall apart. There's a pretty clear gap between what the benchmarks show and how they actually perform on messy real-world input. The thing that gets me is the language homogenization angle. Like, these models are trained and tuned to produce clear, fluent, frictionless text. Which sounds good. But that process might be stripping out the semantic variance that makes language actually rich. Everything starts sounding. the same? Smooth but kind of hollow. I've noticed this in my own work using AI for content, where outputs are technically correct but weirdly flat in tone. There's also the philosophical debate about whether any of this counts as "understanding" at all, or if it's just very sophisticated pattern matching. Researchers seem split on it and honestly I don't think there's a clean answer yet. Curious whether people here think better prompting can actually close that gap, or if it's more of a fundamental architecture problem. I've had some luck with more structured prompts that push the model to reason through context before answering, but not sure how far that scales.