Uncategorized

AI is Great – Simplicity Reigns Supreme.

cantechit Uncategorized , , ,

This isn’t going where you think it is…..

AI is genuinely great. It lets people like me ship real things that used to require teams. I’ve lived that shift. But here’s the part we keep glossing over: simple is often better…… And left to its own devices, AI will almost never choose simple on its own.

I’ve been thinking about this while spending time under modern trucks.

The rats nest under the hood

Pop the hood on a current F-150 Platinum PowerBoost – which I have, or a comparable GM truck even just a 5.3L V8, and you’re looking at a high-power, very complex V6/V8 that is a packaging and repair nightmare. Twin turbos, hybrid components, layers of sensors, modules, coolant lines, wiring harnesses that snake everywhere, and enough emissions hardware to make a mechanic reach for the diagnostic tool before the wrench. The engine bay is a rats nest. When something fails — and things do fail — the labour to get at a relatively inexpensive part can easily run into the thousands.

Ford Broncos are the same story. High-output turbo engines packed with electronics. The complexity is driven largely by emissions standards and efficiency targets, plus the industry habit of adding every electrical doo-dad that marketing can sell. Many new vehicles (Looking at you Rivian!!) Air suspension is a perfect example. Plenty of owners who keep these vehicles long-term eventually rip it out because it becomes a reliability and cost problem. The truck often complains electrically when you do. We’re still putting systems in vehicles that a large percentage of serious owners will eventually delete. I’ve been looking at the Rivian R1T, R1S for years – but with air suspension on board – it’s a hard no, I just won’t do it.

Elon Musk has been consistent on this for years. The core of his engineering algorithm is straightforward: question the requirements hard, then delete every part or process you can. The best part is no part. If you finish a deletion pass and never have to put anything back, you didn’t delete enough — the rule of thumb is that you should be restoring roughly 10 % of what you removed. Only after that do you simplify, accelerate, and automate. He has proven the approach at SpaceX and Tesla. Complexity is the enemy of reliability, cost, and serviceability.

EVs get this closer to right…. Normally.

EVs start with a structural advantage: far fewer moving parts. Even a high-tech Tesla is simpler to work on than a comparable modern internal-combustion vehicle with its turbocharged, hybridized, sensor-laden powertrain. The Cybertruck pushed the idea further with deliberate simplification in structure and systems. With 48V and a simplified network on board, it just kept getting simpler – this was deliberate.

EV makers are not getting it perfect, no automotive manufacturer does, but as an example, putting a brake line that is uncoated, prone to rust and will 100% require a replacement at some point in an inaccessible spot – is bad design. In the early Tesla Model Y – Tesla routed this brake line above the battery pack, and another – over the rear drive motor. This means to replace those 2 lines requires 16 hours of labour to remove the pack and drive motor – to replace a $50 brake line….. and we were doing so well…

Then there’s Slate. That little EV truck is cool precisely because it starts simple. Minimal features from the factory, focus on the basics, customizable after the fact. I like the philosophy. Please give us an AWD option and a modestly larger battery pack as choices. Simple is the goal, but drivability and real-world usability still matter. You can keep the core simple while offering the capability people actually need. Being able to replace parts myself, no real stereo because my phone is enough, crank windows – all good concepts. Telling customers, it comes in one colour – and eliminating that. There’s a reason the “Scion” idea of 1000 options didn’t work here.

There has to be a balance.

The 2026 Tacoma reminder

I recently spent a few hours under a brand-new 2026 Tacoma with the 2.4 L turbo four-cylinder. What struck me wasn’t that it was primitive — it still has modern emissions equipment, direct and port injection, a turbo, the usual sensors. What struck me was access. I could see how to get the fuel injectors out. The alternator was reachable. The turbo itself was accessible with hand tools. I could “get to stuff” without inventing a thousand-dollar labour story to replace a thirty-dollar part. Even with today’s regulatory load, Toyota managed to keep the layout serviceable. That is a design choice. What we don’t want, is planned obsolescence to be a design choice – but one look at automotive youtube, specifically the likes of RichRebuilds, or CarMods and we see sub 10 year vehicles that are “Electrically totalled”. If we are concerned about sustainability maybe this, more so than exhaust should be a target.

Contrast that with the old carbureted V8 in an F-100 pickup. Crude by modern standards, but you could understand it, work on it, and keep it running with basic tools and a modest parts budget. Now look at a modern luxury V8 sedan. Layers of complexity, electronic everything, packaging that prioritizes packaging density and feature count over the ability of a competent owner or independent shop to keep it alive. The disaster isn’t power or refinement. The disaster is that the vehicle becomes a black box that only the dealer can economically touch once the warranty is gone – and repairs that are so expensive that replacing a brake line totals a 5 year old vehicle (Yes that happened to me).

Simplicity as a design constraint – bring it back…

Simplicity must be treated as a hard design constraint in modern engineering. It can also be a constraint on AI design and AI-assisted development — but only if you force it. AI will not choose simplicity on its own.

Left alone, a strong model behaves like a university graduate who is an idiot savant: enormous knowledge, pattern-matching power, zero lived experience of the long-term cost of complexity. It will happily add another layer, another abstraction, another dependency, another configuration option because it can. It has no scars from debugging a rats-nest wiring harness at 11 p.m. or explaining a $4,000 labour bill for a $40 sensor.

So what can you actually do?

In your bootstrap prompts, in your CLAUDE.md, in your system instructions, in whatever scaffolding you use, put rules that treat simplification as non-negotiable:

  • Simplification is paramount.
  • Do not over-complicate.
  • Everything added to this project must be justified by real workload and measured against the bloat it introduces.
  • Prefer the simplest solution that fully solves the stated problem.
  • Before adding any new component, module, dependency, or abstraction, explicitly justify why it is required and what breaks if it is removed.

Force the model to argue for every addition. Make it prove the part is necessary the same way Musk forces engineers to prove a requirement. If you don’t, you will get impressive-looking systems that are fragile, hard to maintain, and expensive to evolve — the software equivalent of the PowerBoost engine bay.

AI is an extraordinary tool. It is not a substitute for taste, restraint, or the hard-won knowledge that comes from owning the long-term consequences of design decisions. Guide it hard toward simplicity or it will cheerfully help you build the next generation of beautiful, unmaintainable complexity.

In the meantime, I still want something closer to the mechanical honesty of that old carbureted F-100, not the elegant disaster that a modern high-end powertrain has become. Simple isn’t nostalgia. It’s survival.

Authenticity is not a weakness, and it shouldn’t be your downfall.

cantechit Uncategorized , , , ,

A break from doing the tech to working in tech….

I’m me. People who actually know me, know me. I’m nowhere near perfect. I have a ton of flaws, and over the years I’ve tried (sometimes hard, sometimes not hard enough) to become a better version of myself. Sometimes it’s two steps forward and ten steps back. Sometimes I catch myself mid-mistake and think, “Why the hell did I just do that?” and I’m genuinely pissed at myself for it.

The reality is I push. I’ve always pushed. As a kid I tested every limit, and as an adult I still do. Other people seem to have learned the softer edges of that impulse. I know the edges exist. I just… don’t always stop at them. It’s not ignorance. It’s wiring.

I’m driven to do big things. I get a lot of FOMO. I’m not a university or college grad, and that fact has sat in the back of my head for decades like a quiet countdown timer. The fear that at any minute the career could end and I’d be back doing whatever random job I could find. When I screw up, that specific fear hits hardest. I still wake up some mornings thinking “I’m getting fired tomorrow.” People say “You’d get hired anywhere.” Ever actually tried that in a competitive space when the narrative isn’t clean? It’s not the soft landing people imagine.

At my core, the thing that cuts both ways is authenticity. Wearing my emotions on my sleeve. Being exactly who I am in the moment. That same authenticity is what gets me in trouble sometimes, and it’s the thing I worry will one day burn the whole thing to the ground.

We live in a world where one mistake, one slip, one sentence said out loud or typed too fast can’t be taken back. The permanent record is real now. Even writing this I’m sitting here asking myself “Should I really put this out there?” or “Maybe I should just keep quiet.” – I have colleagues who made one mistake too far, and an angry mob turned friend to foe, and did everything they could to burn that person career and life to the ground. I have seen some ugly ugly things done by angry internet mobs against people who made a bad mistake. Humans make mistakes, it doesn’t make some of what I have seen in the past ok.

Pick any of the thousand diagnoses floating around. I’m sure I have a little bit of all of them. I just think it’s the human condition. The drive, the FOMO, the self-doubt, the occasional emotional overshoot — they’re not unique. Research keeps showing that something like 70% of professionals deal with imposter feelings at some point. Even people who look like they have it completely figured out still hear the same voice.

Brené Brown has spent years studying this exact tension. She describes authenticity as “a collection of choices that we have to make every day. It’s about the choice to show up and be real.” She also warns that trading authenticity for safety often exacts its own cost — anxiety, resentment, a kind of quiet grief. Vulnerability is the birthplace of the good stuff: connection, courage, creativity. But she never pretends it’s risk-free. I feel this to my very core.

I’ve been a people leader for about 15 years now, and the one thing I keep learning is that leaders never stop learning how to be better leaders. Two people I keep coming back to are Brené Brown and Marcus Buckingham. They come at it from different angles, but they both point at the same hard truth.

If you want authenticity and vulnerability on your team, you have an obligation to respect it, honour it, even cherish it. And if you’re going to do that, you also have an obligation to be prepared to pull the chute when someone goes over the line — and to do it in a respectful, leadership way that helps them rein it in. The key is not kicking them when they’re down. Being too safe, as Brené talks about, creates its own problems. We want our people to be vulnerable, which means we have to show them it’s actually okay to be. That requires creating the conditions where they can drop the armor without getting punished for it.

There’s another version of this that doesn’t look like punishment but still wears people down. Someone once called it “toxic coaching” — the leader who is constantly pushing people to be better, even when something is already good. If you catch yourself saying “that’s great, but…” all the time, that might not actually be great. Sometimes good things need to just be good things. Constant developmental pressure, even when well-intentioned, can feel like the armor never gets to come off. People stop bringing their real selves because they know the next sentence is always going to be the improvement note.

Marcus Buckingham has always pushed the idea that great managers don’t treat everyone the same. They see the individual. They focus on what people do best and help them lean into it. Authenticity isn’t some soft luxury — it’s the only sustainable way to get real contribution. People can smell when you’re faking it. As he puts it, if you’re faking your beliefs, they can smell it, and they don’t want to follow it. The same applies upward. I want to be authentic because being fake is exhausting. It’s like a six-year-old’s lie that just keeps compounding until you can’t even remember the first one, and now you’re in real trouble.

But authenticity only works if the people above you have enough humility and compassion to meet it. If you want vulnerability from your people, you have to lead with compassion. You can’t constantly brow-beat them — or constantly coach them — and then act surprised when they put the armor back on. Who we are is how we lead. If the environment only rewards the polished, controlled, or perpetually improving version, that’s the version you’ll get — and you’ll lose the real contribution that comes with the unfiltered one. This will require real cultural change in organizations to achieve.

So what do you do with that?

I don’t have a clean system. All I really have is the same imperfect loop most of us run: notice it, feel the regret, try to do better next time. Name the pattern when it shows up. Lean harder on the people who already know the full version of you — the ones who can say “Hey man, I get it, you’re upset, that’s okay” without making it a referendum on your character. My best friend does that for me. He knows me better than almost anyone, and I suspect it’s because he’s wired the same way. He is my 1000% safe space, he’s the one I can call 24×7, who will drop whatever and listen to me. Now don’t get me wrong, he won’t sugar coat, or tell me it’s ok if I did something wrong – but as he says “Let’s do the floor work”. He knows who he is, and I cherish him like no other human on earth for being my friend.

And yes — sometimes when things get frustrating or the pile gets too high, I catch myself thinking “Can’t I just get someone else to do this?” because I’ve had enough. That’s human too. The work is learning when that thought is a legitimate signal to rest or ask for help, and when it’s just the old escape hatch. Adulting is hard.

If you’ve had a bad interaction with someone — personal or professional — try giving them a little grace. You don’t know the full weight they’re carrying that day. Most of us are doing the best we can with the wiring we were given, and the scoreboard rarely looks as clean from the inside as it does from the outside.

I’m still trying. That’s all I’ve got.

Usage-Based Billing for AI Tokens: The Drug Dealer Playbook – Targeting Enterprises

cantechit Uncategorized , , , ,

I’ve been saying this shift was inevitable for months. As AI moved from simple chat completions to full agentic workflows—long-running sessions, repo-wide reasoning, multi-step coding, massive contexts—the old flat subscription models became unsustainable for the providers. They got us hooked on the productivity gains at low, predictable prices. Now the meter is running, and the real cost is landing on users and businesses.

This isn’t just “aligning pricing with usage.” It’s classic enshittification: subsidize aggressively to drive adoption and dependency, then flip to usage-based billing (UBB) once the habit is formed. The result? Tokens under pure UBB or Enterprise plans are dramatically more expensive for serious use than the personal subscription tiers. It’s price gouging dressed up as “flexibility,” and it gatekeeps advanced AI behind corporate budgets. That stifles exactly the broad experimentation and innovation that made these tools explosive in the first place.

GitHub Copilot’s June 1, 2026 UBB Transition: Many Businesses Are Now Feeling It

GitHub announced in late April that all Copilot plans would move to usage-based billing effective June 1, 2026. Premium Request Units (PRUs) are gone. In their place: GitHub AI Credits (1 credit = $0.01).

  • Copilot Pro: $10/month includes 1,000 credits
  • Copilot Pro+: $39/month includes 3,900 credits
  • Business: $19/user/month includes 1,900 credits (pooled)
  • Enterprise: $39/user/month includes 3,900 credits (pooled)

Base seat prices stayed the same. Code completions and Next Edit Suggestions remain unlimited and free. Everything else—chat, agentic features, reviews—now consumes credits based on actual tokens (input + output + cached) at rates that track the underlying model APIs (e.g., Claude Sonnet-class output often ~1,500 credits per million tokens / $15).

The “before” vs “now” reality for many organizations: Previously, you paid a flat per-seat fee and got a quota of requests that felt reasonably generous for mixed use. Heavy but not insane agentic work often stayed within limits or had softer fallbacks. Now the included credits are a small bundle (often just a few days of serious use for power users or teams), after which you pay full freight or hit admin-set budgets/throttles.

Developers and admins are reporting exactly what I expected: normal interactions burning 10–100+ credits, complex agent sessions or long-context work torching hundreds to thousands in one go. One widely shared example showed a single meaningful request consuming 822 credits. Reddit megathreads and Hacker News threads are full of “this feels like a price increase in disguise,” “you get less for the same money,” “credits vanish in a day of real work,” and people canceling or moving to direct API + tools like Cursor to escape the middleman markup and unpredictability.

Many businesses that were happily on flat Business/Enterprise seats are now effectively on UBB—either buying extra credits or restricting usage. The “sustainable for all users” framing from GitHub doesn’t change the math for heavy/agentic workloads that are becoming the norm.

Claude: Personal Max Subscriptions Are Way Cheaper Than Enterprise UBB — Here’s the Math

This is the clearest steelman of the problem.

Personal plans (claude.ai / apps):

  • Pro: ~$20/month ($17 annual)
  • Max 5x: $100/month
  • Max 20x: $200/month

These deliver high (or very high) usage limits, priority access, advanced features, and Claude Code. On the platform itself you also get favorable caching treatment in many cases. Cost is capped and predictable even if you push it hard. Real users (including heavy devs) report that Max 5x often covers aggressive daily/weekly use without hitting walls, and the effective per-token cost is subsidized by the subscription model. I am a MAX user, this is what I use for my personal projects, this is predicable, fair – but I will openly admit, it feels VERY VERY cheap for what I am getting, the value is insane.

Enterprise / Team plans:

  • Seat fee (roughly $20–30+/user/month or custom, often annual) plus every token metered at full Anthropic API rates on top.
  • No big included usage bundle in most cases. You pay the API rates (plus any cache write costs) for chat, Claude Code, agents, etc.

API rates (Sonnet-class, current): ~$3 / $15 per million input/output tokens (Opus higher at $5 / $25; Haiku much cheaper). Cache writes add extra. Prompt caching and batch help, but the meter still runs on serious volume.

Realistic comparison (Sonnet-class equivalent, approximate June 2026):

Usage ScenarioEst. Monthly Tokens (in/out)Personal Max Cost (flat)Enterprise Est. Cost (seat + tokens)Personal is ~X Cheaper
Light (casual/pro)~5M / 1M$20 (Pro) or $100~$25 + ~$18 = ~$432x+
Medium (power user)~30M / 8M$100 (Max 5x)~$25 + ~$210 = ~$235~2.3x
Heavy (agentic/dev work)~150M / 40M$200 (Max 20x)~$25 + ~$1,050 = ~$1,075~5x
Extreme (high-volume/team)500M+ / 100M+$200 cap~$25 + $3,500+15–20x+

These aren’t theoretical. Users have posted concrete examples of burst/heavy months where API-equivalent cost hit $6k+ while their Max subscription stayed in the low hundreds. The personal Max tiers effectively cap your exposure. Enterprise UBB does the opposite—it scales linearly with every token the agents and long contexts consume.

“Before” context: Early agentic experiments and lighter workloads could sometimes ride on more generous included usage or experimental pricing. As capabilities (and token burn) exploded, providers standardized on metered models that maximize revenue from the heaviest users.

(The chart above is illustrative of the divergence. Personal Max stays relatively flat thanks to high limits and the subscription model. Enterprise UBB rises sharply with volume because every token is charged at full API rates. Real numbers vary with caching, model choice, prompt efficiency, and exact seat pricing.)

This Is Gatekeeping Innovation

Yes, inference hardware and energy have real costs. But efficiency is improving fast, and the pricing shift isn’t primarily about passing through savings—it’s about capturing more of the value now that users are locked in and workloads are exploding with agents.

The practical effect: serious, iterative, agentic AI work becomes reliably affordable only for companies with big budgets who can either negotiate custom deals or absorb surprise bills. Individuals, indie hackers, small teams, researchers, and startups get priced out or forced into constant cost anxiety. That directly reduces the surface area for experimentation and unexpected breakthroughs. The same tools that were democratizing coding and reasoning a year ago are now quietly recentralizing power.

It’s the worst kind of rent-seeking: hook the ecosystem on accessible tools, then flip the switch once dependency is high.

Louis Rossmann Called It (and So Did I)

YouTuber Louis Rossmann recently lost it on Anthropic in a video titled “Anthropic is worse than my high school’s drug dealer” He highlighted sneaky billing gotchas (extra charges triggered by certain files without clear notice), testing users’ willingness to pay more by restricting previously included capabilities on base plans, confusing docs/UI, and rapid destruction of goodwill. His analogies landed exactly on the drug-dealer / predatory-ISP vibe: get people comfortable and productive, then start metering and testing how much more you can extract. I watched that one and was yelling at the screen because it was exactly what my article back on May 5 was saying

The Copilot move follows the same pattern. Widespread community reaction (Reddit, HN, etc.) echoes it: “Silicon Valley playbook—subsidize to dominate, then raise prices once everyone’s dependent.” “Bait and switch.” “Unpredictable costs that kill the joy of just building.”

I’m not shocked. I’m annoyed because it was predictable, and because the execution prioritizes short-term extraction over long-term ecosystem health.

Bottom Line & What You Can Actually Do

Usage-based billing for frontier AI tokens is here for real workloads on the major platforms. Personal subscription tiers (especially Claude Max) remain the best value for heavy individual or small-team use because they cap the damage – for now I promise you changes are coming. Once you’re pushed into pure Enterprise UBB or post-included-credit Copilot territory, the economics flip hard against you.

Practical steps:

  • Audit your actual usage now (GitHub has preview tools; Claude usage dashboards exist).
  • Optimize ruthlessly: right-size models (Haiku for simple stuff), aggressive caching, shorter focused contexts, prompt discipline. Avoid opus for coding!
  • For individuals/power users: Max-tier personal subs or direct API + lean tools are often cheaper than Enterprise.
  • For teams: Set hard budgets/spend alerts immediately. Negotiate. Consider hybrid (personal subs where possible + governed Enterprise).
  • Long-term: Watch open/local models and alternative platforms. The current model creates a massive incentive for better options.

I saw this coming when agentic usage started eating compute. The “drug dealer” phase—get everyone hooked on the cheap high—worked exactly as designed. Now we’re in the “pay up or slow down” phase.

This approach might maximize revenue for a few quarters. It will not maximize innovation across the board. And that’s the part that actually pisses me off.

If you’re running real workloads on these tools, track your numbers closely this month. The difference between “still feels like a good deal” and “what the hell just happened to my bill” is smaller than most people realize—until it isn’t.

I just don’t want the fun to be over.

I’m an AI Slop Builder. Here Are Two Things That Actually Made Me Better At It.

cantechit Uncategorized , , , ,

Continued in my AI series….

I don’t write code (I know, broken record) . I read it a bit. My contribution to any codebase is mostly vibes, bad variable name suggestions, and extremely strong opinions about what the button should look like. What I am is someone who has spent a lot of time building real, working things using AI — and making every possible mistake along the way before stumbling backwards into something that actually works.

I call myself a builder but really I am a AI Slop Builder. It’s self-aware. It’s accurate. And I’m not embarrassed by it — because I’m trying to do it better.

This week: two things that changed how I build. Neither of them requires you to know how to code. Both of them require you to change a habit that feels comfortable right now but is quietly killing your projects.

First, Let’s Talk About the Mess You’re Already In

If you’ve been using AI to generate code, there’s a good chance you’re doing something like this:

You open ChatGPT, or Grok, or Claude. You paste in some context. You ask it to write something. It does. You copy it somewhere. Then, twenty prompts later, you can’t remember what it changed, why it changed it, or whether the version you have in your editor is even the same thing you were just talking about. The AI has forgotten everything you told it in session one. You’ve got three browser tabs open, a folder called project-final-FINAL-v3, and a vague sense of dread.

Sound familiar?

Here’s the core problem: the context window is finite, your project is not. Every conversation starts fresh. As your project grows, the gap between what the AI knows and what your project actually is gets wider and wider. You spend more time re-explaining than building. You’re not an engineer. You’re a copy-paste operator with ambitions.

There are two habits I changed that fixed most of this. One is about memory. One is about who you’re talking to.

Tip 1: Stop Being Afraid of GitHub. Your AI Isn’t.

I avoided GitHub for years. It felt like something developers did — something with terminals and commands and merge conflicts that would make me feel stupid. And honestly? The first time I poked around in it, I did feel stupid.

Then I realized something: I don’t have to understand Git. My AI does.

GitHub isn’t just version control. It’s a project memory system. And once I started treating it that way, everything clicked.

Here’s what I mean. GitHub has a built-in feature called Issues — it’s basically a ticketing system baked right into every repo. You can log a bug. You can describe a feature you want. You can write out a problem you hit and how you think it should be solved. And then — this is the part that changed things for me — you can hand that issue directly to an AI agent and ask it to resolve it.

The beautiful side effect? You now have a paper trail. Every issue you close is a record of a decision that was made, a problem that was solved, a feature that was built. That record doesn’t disappear when you close your browser tab. It lives in the repo. Permanently. I even use it for research purposes, if I have ideas, I log it as an “idea” and then ask an agent to go off and research it for me.

And here’s why that matters more than you think: the agents also have access to it.

Tools like Claude Code, Cursor, and GitHub Copilot Workspace can read your issues, your pull requests, your commit messages. When you build with GitHub as your source of truth instead of a chat window, the AI isn’t starting blind every session — it has context. Real, structured, version-controlled context that you built up over time just by logging your work like a normal human being. It can operate Retrieval Augmented Generation on our issues.

You don’t need to run a single terminal command to start. You can create a repo, write issues, and review pull requests entirely through the GitHub web interface. Ask your AI how. Seriously — just ask it to walk you through it. That’s exactly the kind of thing it’s good at.

The habit shift: Before you ask AI to build something, write it as an issue first. One or two sentences is fine. “Add a login page that accepts email and password.” Done. Now you have a record, a reference, and a task your agent can actually grab and run with — instead of trying to hold all of that in one immortal chat thread. More important, before you start a project, open a Github repo right away, start with a great environment.

Tip 2: Stop Asking Your Chat Window to Write Code. That Is Not Its Job Anymore.

This one is where I felt the biggest shift — and where I also made the most embarrassing mistakes before I figured it out.

Most people start the same way I did. You’re in a chat window. You’re talking to the AI. You ask it to build something. It builds it. You copy it. You paste it. You come back, ask it to fix something, copy it again, paste it again. Rinse and repeat until you want to throw your laptop out a window.

The problem is you’ve turned your AI into a code vending machine instead of what it could actually be: a manager.

Here’s what I mean. Modern agentic AI — the kind baked into tools like Claude Code, Cursor, Windsurf, or even more advanced configurations of ChatGPT — isn’t just a chat box anymore. These tools can spawn subagents: separate, focused AI workers that handle specific tasks in their own isolated context, then report back. One subagent writes code. Another reviews it. Another runs tests. The manager — the agent you’re actually talking to — coordinates all of that without dumping it all into one giant, bloated conversation.

Every developer who uses these tools long enough hits the same wall. The session starts fast. The first hour is productive. Then, somewhere around the third or fourth hour, responses get vague, the model starts forgetting decisions made earlier, and code suggestions drift. The context window is full — and it’s full of noise.

Subagents are the fix. The orchestrator — the agent you talk to — doesn’t do the heavy lifting. It coordinates. Each subagent receives a focused prompt with a clear objective, does the work in its own clean context window, and returns only the relevant result to the manager. You don’t see the mess. You just see the outcome.

But here’s what nobody tells you: the AI will not do this automatically just because you asked it to build something complex. You have to prompt it differently.

When I stopped asking “can you build me X” and started saying “you are a manager agent — plan this work and delegate the implementation to subagents, I don’t need to see every step” — the quality went up, the conversation stayed clean, and I stopped copy-pasting like a maniac.

Think of it like being a project manager who delegates to specialists. You wouldn’t ask your designer to run security audits or your QA tester to write marketing copy. Same logic applies here. Stop asking your chat window to be everything. Give it a role. Give it authority. Tell it to delegate. “I have this cool idea for a new way to this thing, here’s the idea, but I want to research it, spin up a sub agent to research it and document the findings in an issue”

The other shift: if you’re doing this in a plain chat window, you’re leaving tools on the table. Most of the serious agentic tools — Claude Code, Cursor, Windsurf — have proper support for subagent workflows baked in. They can read files, write files, run commands, check your GitHub issues, and loop back for review. A chat window can describe doing all that. A code agent can actually do it. That’s not a small distinction. That’s the whole ballgame.

You don’t need to understand how subagents work under the hood. You just need to know they exist, prompt for them, and get out of the way.

The Real Lesson Under Both Tips

What both of these tips have in common is this: AI works better when you give it structure, not just requests.

GitHub Issues give your project structure. A manager-agent prompt gives your workflow structure. Without structure, you’re just vibing your way through a chat window hoping something sticks. With it, you’re running something that looks a lot more like an actual software team — even if that team is entirely made of ones and zeros and you’re the only human in the room.

I’m still an AI Slop Builder. I’m not going to pretend I’ve got this all figured out. But I’ve at least graduated from copy-paste chaos to something that feels intentional — and honestly, that’s more than I expected when I started.

Next time, we’re going to talk about something that sounds simple but is probably where most people are losing the most ground: prompt engineering. Specifically — what do you actually put in that little empty box? I’ve been building up a set of tips, bootstrapping tricks, and hard-won lessons about how to talk to these things so they actually do what you want. It’s less mystical than the name suggests, and more impactful than you’d expect.

AI Was Supposed to Give Me My Time Back. Spoiler: It Didn’t. And Honestly, I’m Part of the Problem.

cantechit Uncategorized , , , ,

Let’s do the math out loud.

I’m shipping somewhere between 10x and 20x more output than I was two years ago. Internal tools that would’ve taken a contracted dev team six weeks now take me an afternoon. Research that used to mean three days of tab-hopping is a 20-minute prompt chain. Whole apps — real, working ones — get vibed into existence on a Saturday while my kid eats cereal.

By every productivity logic ever invented, I should be working two days a week.

I’m working closer to seven if you add up work and personal projects.

What the hell happened? AI was supposed to be the thing that finally gave us the time back. Instead it gave us more work to do, more things to chase, more rabbit holes to fall into, more shiny new tools to evaluate, more agents to babysit. The output went up. The hours didn’t go down. If anything, they went up too.

I keep telling myself I’ll write less this week. I keep not doing that. Rathole, I have been asked why I stopped writing – I used to do it more, but as I always say – I’ll write when I feel like I have something to say – lately it’s becoming clear in this series I do, if nothing else it’s cathartic for me to write it down even if I am not sure if someone is listening

Henry Ford Already Proved This Was Possible — In 1926

Here’s the part that drives me a little crazy.

On May 1, 1926, Henry Ford cut his factory workweek from six days to five — 40 hours instead of the usual 50-60 — and kept everyone’s pay the same. He didn’t do it because he was a saint (he absolutely wasn’t). He did it because he’d been quietly studying his own workforce and found something the rest of industry didn’t want to hear: tired workers made more mistakes, had more accidents, and produced less per hour than well-rested ones.

Ford famously said it was “high time to rid ourselves of the notion that leisure for workmen is either ‘lost time’ or a class privilege.” Productivity went UP after the change. Loyalty went up. Turnover went down. Other manufacturers grudgingly followed. Twelve years later the Fair Labor Standards Act made the 40-hour week federal law in the US.

That’s the model. Less hours, same (or more) output, better humans. Proven a century ago with a stopwatch and a Model T assembly line.

So now, in 2026, when I have a tool that legitimately makes me 10-20x faster at most of what I do — by the Henry Ford logic, my workweek should be collapsing. Not just to four days. To two.

And it’s not.

Why It’s Not Happening (And Won’t)

I went looking for the answer in a few places. It’s not one thing. It’s a stack.

Microsoft’s own data is the kicker. Their 2025 Work Trend Index surveyed 31,000 workers across 31 countries and crunched trillions of M365 productivity signals. The headline result: knowledge workers are now interrupted on average every two minutes — 275 times a day. This is entirely my life, I could write entire articles about how I don’t do my best work when I am task switching. One in three say the pace of the last five years has made it impossible to keep up. 53% of leaders demand productivity increase; 80% of the workforce reports they don’t have the time or energy to do effective work. Microsoft literally calls it the “Infinite Workday”. Their own warning is brutal and quotable: we risk using AI to accelerate a broken system.

Which is exactly what’s happening. We didn’t redesign the workday around AI. We just bolted AI onto the existing infinite one and made the meter spin faster.

Then there’s Jevons. I mentioned this in my Cisco AI Summit post — Sam Altman flagged it on stage. The Jevons Paradox is the 19th-century observation that when something becomes more efficient to use, we don’t use less of it; we use way more. Coal got cheaper, coal consumption exploded. Compute got cheaper, compute consumption exploded. Now AI is making knowledge work cheaper, and Box CEO Aaron Levie went viral last December arguing the same thing applies: cheaper intelligence won’t shrink work, it’ll expand it. The bar for “what counts as a deliverable” just keeps moving up.

French consultant Bertrand Duperrin nailed it in a February 2026 piece on AI work intensification: if nothing stops, then everything gets added. AI becomes a machine for densifying, for multiplying iterations, for expanding the scope of what’s required. Less a transformation of work than an intensification of it.

That’s me. That’s exactly me. I’m not doing less; I’m doing the same five-day week with five times the surface area.

And the historical pattern says don’t expect this to change. Back in 1930, John Maynard Keynes wrote a famous essay called “Economic Possibilities for our Grandchildren” predicting a 15-hour workweek by 2030. He wasn’t crazy — he just assumed humans would bank productivity gains into leisure. A 2022 LSE revisit of the prediction found the productivity gains absolutely happened (real GDP per capita more than quadrupled), but we didn’t take them as time off. We took them as more stuff, bigger houses, longer retirements. Lifetime leisure DID rise about 58% in the UK — but almost all of it from people living longer in retirement, not from working less while employed.

We’re four years from Keynes’ 2030 deadline. The average full-time worker is nowhere near 15 hours. The Henry Ford 40-hour week, set up for factory floors a hundred years ago, is somehow still the ceiling and the floor for knowledge work designed for digital agents.

So the world had its chance — multiple chances — and chose more consumption over more time, every single time.

The Confession: I Could. I Won’t.

Here’s the part where I have to be honest, because this whole post would be a cop-out otherwise.

I’m not just a victim of the system. I’m one of the people running the meter.

Could I do my actual “value” work in two days and then sit on my hands for three? Honestly, probably yes. METR’s May 2026 survey of technical workers puts the median self-reported speed change from AI at 3x and median value-of-work change at 1.4–2x. I’m self-aware enough to know I’m above the median — building with multiple agents in parallel, vibe-coding tools in hours that used to take weeks. The math is the math. I could compress.

But I won’t. And not because some boss is making me — I’m in a fairly senior role and I have a lot of control over how I spend my hours. The reasons are uglier and more personal than that:

  1. I’m addicted to the capability. I wrote about this in AI Companies Are Straight-Up Drug Dealers. When the billing glitch killed my agentic access for two days I felt actual withdrawal. Sitting on my hands for three days a week while I have a Claude Opus session sitting RIGHT THERE that could be building something? Not happening.
  2. The competition resets the bar instantly. I wrote about this too in Falling Behind. The second I deliver an internal tool in two days that used to take six weeks, that becomes the new normal. Next week’s ask is bigger. There’s no going back to the slower pace because the world I work in already adjusted to the faster one.
  3. I want to build cool stuff. Two days a week of work means three more days of “what should we build today?” That’s not rest. That’s just a different kind of building. I’m also building my own stuff on my hours and days off.. Disconnecting is harder than ever.
  4. My brain is buzzing along with the GPU. I wrote about this in The AI Acceleration Trap — the VRM hum, the insomnia, the skipped meals. I KNOW it’s costing me. I keep going anyway. That’s not a productivity story. That’s an addiction story dressed up in productivity clothes.

And here’s the kicker — there’s a 12-person software startup called Convictional that actually did the Henry Ford move in mid-2025. Moved to a 32-hour, four-day workweek. No pay cut. They credited AI absorbing enough manual work to make it possible. One company. Twelve people. That’s the entire counter-evidence I could find. Nobody else is volunteering this. Bosses won’t. Boards won’t. Investors won’t. Jevons won’t. And honestly? Neither will I. If I do it, someone else will be glad to keep the 40 hour.

So What Do We Do? Honestly… Probably Nothing.

This is the part where I’m supposed to give you the five-point action plan to reclaim your time, and I’m not going to insult you with one. I don’t have one. The 5-day, 40-hour week survived the Industrial Revolution, electrification, the PC, the spreadsheet, the smartphone, the internet, the gig economy, and a global pandemic. It’s not going to fall to AI either. The only thing that changes is how much we cram into those five days.

It’s a little like the line in rally — there’s a place on every stage where you KNOW the smart move is to lift off the throttle, scrub some speed, and bank a clean exit. And yet the same drivers who know that, including me on Fire Access Road 507 with absolutely no prize money on the line, keep their foot in it. Because the throttle feels good and lifting feels like losing. The math says lift. The hands keep pressing.

So I’m not lifting. I’ll aim for the traction from the ruts like Crazy Leo taught m, I’m probably going to keep pushing 6-7 days a week. I’ll keep my guardrails from the Acceleration Trap post — protect sleep, eat actual meals, take walks, keep the agents on a leash so they don’t burn through credits or my nervous system overnight. But the workweek itself? It’s not getting shorter for me, and unless your boss is Henry Ford reincarnated as a 2026 CEO with a stopwatch and a conscience, it’s probably not getting shorter for you either.

May as well enjoy the ride. Just don’t ignore the buzzing.

Your turn: Are you doing 5-10x the work in the same hours and getting away with it, or have you actually carved out time back? Did your employer give it to you, or did you take it? Or are you like me — could compress your week to two days and refusing to, because the dopamine and the FOMO are louder than the math? Drop it in the comments. I’m reading every one.

(Catch up on the AI builder series if you’re new: Falling Behind → AI is Underpriced (But Not For Long) → GitHub Copilot Price Jump → Drug Dealers → The AI Acceleration Trap → and now this one.)

The AI Acceleration Trap: Loving the Speed, Paying with Exhaustion, Insomnia, and Skipped Meals

cantechit Uncategorized , , , ,

Yes, I’m still writing about my AI builder journey, the most out of me in YEARS… I get it, I keep saying I would blog when I had something to say… I do now. Coding agents, multiple LLMs running in parallel, vibe-prompting entire features — it’s exhilarating. Search feels prehistoric now; why hunt for links when an LLM reasons through context and synthesizes faster? I open several chat sessions for the same project, treating them like a distributed team of specialists. One for architecture, one for debugging, one for research, one iterating on UI. Output is flying. Tools are built in days, not weeks.

And when I run a capable model locally on my desktop rig? The machine itself comes alive. The GPU spins up under heavy inference load, fans ramping into a deep, resonant hum. But the real star is the VRM buzz — the voltage regulator modules and their components straining to deliver hundreds of amps at precise low voltages. Inductors (coils) vibrate from rapid electromagnetic switching, while the multilayer ceramic capacitors “sing” via the piezoelectric effect as voltage ripples through them. The whole PCB acts like a speaker cone, turning electrical stress into audible whine and physical vibration you can feel through the desk. It throbs in rhythm with token generation, like the system is breathing hard and alive.

I even searched what this sentient-like buzzing and vibration was. Turns out it’s the VRMs and capacitors being heavily taxed under sustained high-wattage load — completely normal physics, not a failing part, but the hardware literally singing under stress as it powers matrix multiplications for hours on end. The rig pushes silicon to its limits right alongside me.

I love it. But it’s costing me. That same low-level buzzing has invaded my own head. Mental exhaustion hits harder and faster. There’s a constant mental static — a vibrating fog that mirrors the GPU’s VRM whine and the case’s resonant throb under load. Focus fragments. And recently, it’s spilled into real insomnia — lying awake replaying prompts and agent outputs — and straight-up skipping meals because I’m “in the flow” until my body protests. This isn’t sustainable. I’m not alone, and emerging research confirms it. This is showing the limit of how fast I can go given so much resource.

The Phenomenon Researchers Call “AI Brain Fry”

A March 2026 Harvard Business Review study from Boston Consulting Group (surveying 1,488 U.S. workers) named this exact experience: “AI brain fry” — mental fatigue from excessive use or oversight of AI tools beyond one’s cognitive capacity.

Participants described a “buzzing” feeling or mental fog, with difficulty focusing, slower decision-making, and headaches. High-oversight users (constantly reviewing, verifying, and orchestrating AI outputs) reported +14% mental effort, +12% mental fatigue, and +19% information overload.

That internal buzz feels eerily synchronized with my local rig’s physical vibration. The hardware’s coils and capacitors strain audibly and tactilely; my brain does the same — silently vibrating from the cognitive load of managing what feels like a team of tireless digital collaborators.

Managing multiple AI agents or chat sessions — exactly my workflow — amplifies it. The study highlights how juggling autonomous tools turns you into a full-time supervisor, not a creator. What was supposed to free time instead intensifies work through constant context-switching and evaluation.

About 14% of AI users experienced brain fry, with higher rates in creative/tech roles. Costs are real: +33% decision fatigue, +11% minor errors, +39% major errors, and 39% higher intent to quit.

The Human Cost: Insomnia, Skipped Meals, and Burnout Spillover — Echoes of Pi

My insomnia and meal-skipping aren’t unique. Earlier research linked frequent AI interaction to disrupted sleep and boundary-blurring. The always-on nature of these tools keeps the mental GPU spinning long after the physical fans wind down.

UC Berkeley/Yale ethnographic work showed AI adoption encourages multitasking, voluntary overwork, and blurred work-life lines. Productivity rises short-term; burnout follows, especially for power users running local models or parallel sessions.

This whole experience is starting to feel disturbingly like the movie Pi (1998) by Darren Aronofsky. If you haven’t watched it, stop reading and go do it — black-and-white, shot on 16mm, scored with a pounding industrial soundtrack that drills into your skull. It follows Max Cohen, a brilliant but tormented mathematician obsessed with finding hidden patterns in π and the stock market. He runs relentless computations on a straining home supercomputer setup while suffering brutal cluster headaches, paranoia, hallucinations, and social isolation.

The film is filled with motifs of buzzing, drilling, and static in Max’s head — auditory representations of his fracturing mind under obsessive load. Migraines come with auras, twitching, and a white-void escape, culminating in desperate self-surgery to “release” the pressure. The parallels hit too close: me chasing emergent patterns and breakthroughs through straining silicon (VRMs whining, GPU throttling), while my own neurons buzz with overload, replaying sessions at 3 a.m., skipping meals, feeling the isolation of deep flow states. I genuinely hope this isn’t foreshadowing my fate. The movie’s warning about the cost of pursuing ultimate truth through machines feels prophetic in 2026.

Why This Hits So Hard with Coding Agents, Multi-Chat, and Local Rigs

  • Search is obsolete for reasoning tasks → LLMs win on synthesis speed.
  • Multiple sessions = team management → Each chat has its own context and hallucinations to catch.
  • Local inference → The tangible VRM vibration, coil whine, and capacitor singing make the acceleration feel visceral and alive — until your own nervous system starts humming in sympathy.

This is the productivity paradox of 2026: AI amplifies output while intensifying the mental (and sometimes physical) work of oversight.

What Now? Sustainable AI Use (Lessons I’m Applying)

I’m not quitting AI — or my local setup. But I’m redesigning and adding guard rails:

  • Batch sessions and set hard cutoffs (including GPU cooldown periods).
  • Protect deep-focus blocks without any models running.
  • Prioritize AI for toil, reserve core judgment for me.
  • Build in recovery: walks, meals, no screens before bed.
  • Track personal metrics (energy, sleep, output quality and GPU/VRM temps).

This topic builds on my recent cantechit posts about vibe coding, agents, and the realities of AI adoption. The acceleration is real. So is the need for guardrails — before the buzzing becomes permanent.

What’s your experience? Local models making your desk (and brain) vibrate with VRM whine? Multiple agents burning you out, or found a sweet spot? Drop comments or links to your workflows.

Sources linked inline. Key reads: HBR on AI Brain Fry and related coverage.

AI Companies Are Straight-Up Drug Dealers

cantechit Uncategorized , , , ,

Free Samples, Then the Hook (And Yeah, I’m in Full Withdrawal)

Look, I wrote this right after a stupid billing glitch with my main AI provider nuked my agentic coding access for two full days. No deep reasoning chains. No autonomous agents refactoring my messy repos. No vibe-coding flow where I spin up tools, iterate like a madman, and ship in hours what used to take weeks.

I felt actual withdrawal. Irritable. Slow. Like my brain was running on dial-up while the rest of me knew what god-mode felt like. That’s when it hit me: these AI companies aren’t just selling tools. They’re dealers. And we’re all hooked.

The Classic Dealer Playbook – Free Samples to Get You Dependent

First they flood the zone with insane value. Generous free tiers, cheap Pro plans, agentic capabilities that feel like having 1-2 full-time devs in your pocket for under $50/month. You get hooked on the productivity superpowers. You start building faster, thinking bigger, shipping stuff you’d never attempt solo. Your workflow changes. Your expectations reset.

Then comes the squeeze.

Everyone’s raising prices. Or doing the sneaky version: shrinkflation on tokens. Same monthly fee, but the model “thinks” less, outputs dumber results, or burns through your quota faster. I’ve seen reports of Claude Opus variants suddenly using 67% fewer thinking tokens for the same tasks. Same price, worse output, more tokens consumed. Classic move.

They’re quietly shifting from flat subscriptions to consumption models – per-call, per-token, usage-based billing (UBB). GitHub Copilot just did it. Anthropic is pushing enterprise users toward metered API rates on top of seats. OpenAI and others are following the same pattern. They pretend the subscription is still the core, but the real work (agentic sessions, heavy reasoning, long contexts) now eats credits that vanish fast. No rollover. Burn mid-project and you’re stuck.

I also see coding agents getting stuck in a loop, when it makes a mistake – wait a second – I’m paying for this tool, and it got stuck in a loop and burned MY credits…. That doesn’t seem fair.

This isn’t random. It’s the plan.

The Humanity Angle: This Technology Must Stay Accessible

Here’s where I get pissed off at the dealer playbook. Let’s stop for just a second.

This shouldn’t just be for those who can afford the new premium rates. AI needs to stay cheap — or get cheap again — because humanity desperately needs broad access to this knowledge and capability.

Think about the 20-year-old kid who couldn’t afford college, grinding in a basement somewhere with a killer idea but no formal credentials. With affordable AI, that kid can prototype, research, iterate, and ship at a level that used to require a full dev team and venture backing. One good prompt chain and they’re competing with people who have more resources.

Or zoom out to emerging markets — places where even $20/month is a real barrier. A developer in Lagos, Jakarta, or rural India with limited local opportunities suddenly has world-class reasoning, coding help, and research at their fingertips. The talent and ideas bubbling up from those places could be the next massive breakthroughs. We’re talking exponential global innovation in emerging markets, if we don’t gatekeep this behind usage-based pricing that prices out the ambitious but broke.

Everyone should have access, not just Western professionals with corporate cards. The more minds hooked into these tools, the faster we solve hard problems in climate, biotech, energy, education — you name it. Imagine the compound effect: millions of new builders creating tools, businesses, and scientific insights we can’t even picture yet. That’s the real moonshot. Locking it behind ever-rising costs kills that potential.

I remember listening to Jake Hirsch-Allen talk about democratizing AI, building a coalition of open democratic economies. Investing in Public AI “The CBC of Compute” he calls it. I recall that line in “Anti-Trust” (A horrible 2* tech film from the 2000’s filmed in British Columbia) “Human knowledge belongs to the world” – Ryan Phillippe said on screen.

Why This Was Always Coming (And Why It’s Not Pure Evil)

Let’s be real for a second – I’m not some conspiracy nut. The economics make sense.

Frontier models are insanely expensive to run. Inference costs, HBM memory shortages, power bills, massive CapEx – the whole industry is bleeding cash even as they raise billions. Demand exploded. They loss-led hard to build market share and moats while compute caught up. The “basically free god-mode AI” era was the sample pack. Now they’ve got us dependent, the bills have to get paid.

Agentic workflows aren’t cheap chats. A multi-hour autonomous coding session that loops, reasons, tools, and iterates eats serious compute. Companies can’t subsidize that forever while memory prices go parabolic and everyone wants Opus-level reasoning.

So yeah – prices up, or shrinkflation, or straight usage-based. Pick your poison. GitHub’s recent Copilot changes (credits instead of unlimited premium requests, Opus multipliers jumping hard) are just the visible tip. More will follow.

We’ve been underpaying for this superpower. Shipping in days what used to need teams? Turning weekend experiments into real tools? That value is still ridiculous compared to hiring humans. But the golden age of predictable flat-rate unlimited was always temporary.

What This Means for You (Practical Moves)

Diversify like your workflow depends on it (it does).

  • Stay flexible: Tools like Continue.dev (bring your own keys) or OpenRouter let you pick the best model without middleman markups. Consider holding accounts with more than one provider, another subscription might be cheaper than overage charges (think 2 bags on the aircraft is cheaper than one overweight one)
  • Watch the credits: Set hard budgets. Test heavy sessions in advance so you don’t get stranded mid-project. Don’t let flows run endlessly.
  • Hybrid stack: Keep one smooth native tool (Cursor, Copilot, Windsurf) for daily flow, but route deep agentic work to raw APIs where you control cost.
  • Build habits: Use AI to multiply your thinking, not replace it. The real moat is knowing when to guide, when to verify, and when to ship.
  • Prompt engineer: Better prompts = better output = more context = less tokens. Learn to plan projects, and use quality prompts, this will save both time, money and of course – Tokens.

I’m still all-in on AI. Sitting with my kid building stuff is next-level. The superpowers haven’t disappeared – the pricing is just normalizing to reality. How can we make this accessible, don’t gatekeep it behind rich corporations. Those who have this power will become superpowers.

The dealer’s got us. Time to use the high productively while we figure out the new economics.

What do you think? Hooked yet?

GitHub Copilot AI Coding Price Jump!

cantechit Uncategorized , , , ,

Hate to Say It… But I Called It: GitHub Copilot Just Went Full Usage-Based Billing – And Yeah, This Is Only the Beginning

If you read my post from April 10 — AI is underpriced, but not for long — you already know where this was headed. Mere days later, GitHub dropped the hammer: Copilot is switching to usage-based billing (UBB) on June 1, 2026. Base subscription prices stay the same, but everything agentic, chatty, or model-heavy now burns through GitHub AI Credits based on actual tokens consumed. No more flat-rate “premium requests” that let you vibe-code all month for one predictable price.

I’ve been living in Copilot (Pro+ tier) for my daily vibe work — that flow-state coding where I’m spinning up internal tools, refactoring messy repos, switching between Claude Opus for deep reasoning and faster models when I’m just iterating. It’s been stupidly good. For under $50/month I’ve effectively had 1-2 full-time devs in my back pocket. The value chain was already ridiculous. Now? It’s breaking.

What Actually Changed (And Why Opus Is the Big Gut Punch)

From the official announcement and FAQ:

  • Copilot Pro ($10/mo) → $10 in AI Credits
  • Copilot Pro+ ($39/mo) → $39 in AI Credits
  • Business/Enterprise get the same 1:1 ratio plus some promo credits for the first few months and pooled usage (nice for teams).

Code completions and Next Edit suggestions stay unlimited and free. Everything else — chat, agentic sessions, code review (which now also eats GitHub Actions minutes) — is metered by tokens. Models have multipliers. And yeah, the one everyone’s screaming about: Claude Opus 4.7 just jumped to 27x credits (from around 3x before). That single model you reach for when you need god-tier reasoning is now nine times more expensive in practice.

No rollover on credits. No more fallback to cheaper models when you hit limits. Burn your allocation mid-project and you’re either waiting for next month, buying more credits, or downgrading your output quality.

The Backlash Is Loud (And Fair – Maybe)

Head over to the GitHub community discussion or Reddit threads and it’s pure salt. Common themes:

  • “This is just a stealth price hike dressed up as ‘sustainability.’”
  • Power users doing real agentic work are staring at $30–$40+ sessions instead of one premium request.
  • Annual plan holders getting hit with multiplier changes before their contracts even expire.
  • “Why would I pay GitHub a markup when I can go direct to Anthropic or use Cursor?”
  • Plenty of “cancelling today” posts. Some devs already switched mid-rant.

I get the rage. We all got hooked on this insane value and now the bill is coming due exactly like I predicted. Companies can’t keep subsidizing frontier-model agentic coding forever while their inference costs explode.

Steelman: This Is Just the Beginning

Look, I’m not here to defend Microsoft. But let’s be real — this is the market finally catching up to reality, not some greedy cash grab in isolation.

Agentic workflows aren’t cheap. A multi-hour autonomous coding session that used to cost them the same as a quick chat question now actually reflects the compute it eats. OpenAI, Anthropic, and everyone else are bleeding cash on training and inference. Memory prices (HBM especially) are still going parabolic. Demand is insane. The golden age of “basically free god-mode AI” was always temporary — it was the hook. Now the moat is built and the bills have to get paid.

I said it two weeks ago with Perplexity Computer at $200/mo and I’m doubling down: we’ve been underpaying for this superpower. The value we’re still getting (shipping in days what used to take teams weeks) is absurd compared to hiring humans. Prices will keep ratcheting up across the board as the industry stops loss-leading to win market share. This isn’t the end — it’s the first big normalization wave.

So Where Do You Go From Here? My Current Shortlist

I’m not rage-quitting Copilot yet (still great for GitHub-native teams), but I’m diversifying hard. Here are the strongest moves that actually integrate cleanly with VS Code or VS Code-style IDEs, ranked for someone doing heavy “vibe coding” like me:

ToolTypeBase PriceUsage ModelModel FlexibilityBest ForWhy I’m Considering It
GitHub Copilot (new)VS Code / JetBrains extension$10–$39/moUBB AI Credits (no rollover)Their curated list (Opus now 27x)GitHub-heavy teams, simple autocompleteStill the smoothest native GitHub integration
CursorFull AI-native IDE (VS Code fork)Pro $20/mo Pro+ $60/mo Ultra $200/moIncluded credits (scales with tier)Multiple frontier models + custom agentsDeep codebase refactoring & agentic workClosest “vibe” replacement — built for this exact workflow
Continue.devOpen-source VS Code extensionFree (core)Bring Your Own Keys (pay providers directly)Literally any model — Anthropic, OpenAI, Grok, local, OpenRouterMax flexibility & cost controlZero markup, switch models mid-session, privacy-focused – but their plugin is buggy for me
Windsurf (Codeium)AI IDE / extensionPro ~$15–20/moMostly unlimited or generous quotasStrong agent layerTeams wanting speed + lower costFast autocomplete with growing agent features

My personal take right now:

  • If you want the absolute closest experience to old-school Copilot but better agentic orchestration → Cursor Pro ($20) is the move. It feels like someone finally built the IDE for AI instead of bolting AI onto VS Code.
  • If you’re a tinkerer who wants to stay in plain VS Code, pick the absolute best model for the job without paying anyone’s middleman markup → Continue.dev + Anthropic/OpenRouter keys. This is my new daily driver for pure flexibility. Costs me whatever the raw API charges and nothing extra. I tried it and had tons of issues with their plugin not working correctly though, so I might take a second look.
  • Heavy teams already deep in GitHub ecosystem → stick with Copilot for now, just set strict budgets and watch the preview bill like a hawk.

The era of one predictable $39 subscription buying you unlimited frontier-model coding sessions is over. But the era of AI replacing entire dev teams is just getting started — and the tools are only getting sharper.

I’m still building with my kid using this stuff. The superpowers haven’t gone away; the pricing is just finally reflecting what they actually cost to run.

What about you? Already cancelled Copilot? Switched to Cursor or Continue? Drop your setup and real-world monthly spend below — I’m genuinely curious how everyone’s adapting.

AI is underpriced, but not for long.

cantechit Uncategorized , , , ,

Perplexity Computer: $200 a Month Feels Like a Steal… But We’ve Been Getting AI Dirt Cheap

If you haven’t watched NetworkChuck’s video on Perplexity Computer yet, stop everything and check it: https://www.youtube.com/watch?v=G3jvn7n-68Y

Chuck and his kiddos built a full gaming website with it. Pure dad-tech gold. His reviews always cut through the noise and save me (and probably you) hours of digging. Thanks, Chuck — you rock.

That video got me thinking about sitting down with my own kid to design, engineer, and build real stuff with AI. Not just prompts — actual projects. Perplexity Computer feels like the perfect playground. But then the price hit: $200/month for the Max tier that unlocks the full agentic power.

And that’s the spark for this post.


Perplexity Computer Is Next-Level (But Is $200/Month Crazy?)

Launched Feb 25, 2026, Perplexity Computer isn’t another chatbot. It’s a digital worker that orchestrates 19 frontier models in parallel, spins up sub-agents, hooks into 400+ apps, runs background tasks for hours or days, and just gets shit done. Full details here: https://www.perplexity.ai/hub/blog/introducing-perplexity-computer


Chuck’s “crew” shipped a game site. Others are building dashboards, prototypes, and entire workflows that used to take teams weeks. One enterprise user reportedly compressed years of work into weeks.

The problem with all of these services is – “tokens” nobody can tell you how many tokens it costs to do X, you only find out once you start doing things, but as I have found out with services like GenSpark and Perplexity – credits go fast, and when you are 3/4 done and run out — they have you.

Yeah, $200/month stings at first glance, others are spending thousands per month with the extra tokens…. but.

We’ve Been Underpaying for God-Tier AI This Whole Time

Look at what we’ve built lately with Claude, GPT, Cursor, and early agents. I’ve personally shipped internal tools and automations that would’ve needed multiple full-time devs, designers, and PMs just two years ago. The human hours I didn’t spend hiring? Massive. The “too expensive to try” ideas that became weekend wins? Priceless. It seems almost too good to be true — but is it.

There is this natural disparity in my mind, which was why I am writing this….. If it cost me say $100K in engineering time to contract hire a bunch of people to build some form of application – but I can use AI to do nearly all of it for $1000 in AI tokens, that’s 1/100th the price… However those engineers are making money.

Meanwhile, the AI companies are bleeding cash. OpenAI has been posting multi-billion-dollar losses. Perplexity has spent more than its revenue on models and infra at times. The compute bill is insane.

Naturally – AI tokens and services are going to go up in price – they just have to.

Then OpenAI shut down Sora in March 2026 — a money pit they needed to kill so they could refocus compute on higher-priority stuff like coding agents and robotics. Details: https://www.nytimes.com/2026/03/24/technology/openai-shutting-down-sora.html

We got hooked on ridiculously capable AI at bargain prices. Perplexity Computer feels like the first big “okay, time to pay what it actually costs” moment – but I will argue they are still not charging enough. Same vibe with Claude — Anthropic has tightened free-tier access for heavy agent use (like third-party OpenClaw setups) and pushed people toward paid Pro/Max/API tokens. Classic addiction cycle: get everyone dependent, then the price catches up to reality. Still arguing it’s not reality but they know they can’t 10X the price overnight.

The Newcomer Worry — And Why Competition + Reality Still Makes Me Hopeful

How do junior engineers learn the fundamentals when AI handles so much of the grunt + magic? Valid fear. We rely on the critical thinking of engineers from their experiences, and AI does a better job when you guide it – but – how do you get that experience to guide it?

But here’s the flip: the barrier to creating has never been lower. My daughter (and Chuck’s kids) can now experiment with real design and engineering at a level that used to require expensive teams or years of school. Passion and curiosity suddenly matter more than raw syntax.

Competition is fierce — OpenAI, Anthropic, Google, xAI, and more. Competition is very good news: it should depress prices a bit and keep innovation humming.

But here’s the steelman reality check: How sustainable is that when infrastructure costs are exploding? AI demand has driven memory prices (especially HBM/DRAM) sky-high — 50%+ jumps quarter-over-quarter in early 2026, with supply locked into 2027. GPUs, data centers, power — everything is getting more expensive fast. The infra bill isn’t going down; it’s accelerating.

So prices will probably ratchet up over time as the companies stop subsidizing our addiction. But the value we’re getting is still absurdly high compared to the old world of human-only teams.

Bottom Line: We’re Not Overpaying — We’re (Starting To) Finally Paying Fair

Perplexity Computer isn’t overpriced. It’s the wake-up that the “basically free god-mode AI” golden age was always temporary. The companies subsidized it to hook us and build moats. Now the bill is coming — but the superpowers we’re getting in return are still a steal.

I’m buying in. Not just for the productivity, but because I want to sit next to my kid and say, “Let’s build something cool together.” The future isn’t replacing humans — it’s giving every human (kids included) superpowers. This is bringing incredible higher value work to the human race. During the industrial revolution everyone worried about jobs, when 80%+ of humans made food so we could eat – often by hand. Now with industrial manufacturing and technology, we have more time for better innovation. This is no different. Will we see job disruption – of course, but this means a whole new era of innovation.

What do you think? Is $200/month worth it for Perplexity Computer? Felt the “addiction then price hike” yet? Drop your takes below.

I feel am falling behind – but so do many.

cantechit Uncategorized , , , ,

Right now, sitting here staring at my screen on a random Thursday morning in April 2026, I feel like I’m falling behind.

This is supposed to be the next post in my AI series – the one where I keep talking about vibe coding, turning coders into builders, and (more importantly) turning non-coders like me into builders and innovators. But today? Today this isn’t going to be another “here’s how I hacked something cool with AI” post. This is going to be an honest, chatty, let’s-be-real moment. I am tired of pretending I’ve got it all figured out. It’s changing faster than I can learn it – and yeah I am feeling some FOMO.

I’ve never felt comfortable in front of an IDE. Never. I open VS Code and my mind goes blank. I’m bad at syntax, the terminal throws errors that feel frustrating, and half the time I’m just copy-pasting whatever the AI spits out and praying it doesn’t explode in project, thankfully never really production. I can look at some of the code I’ve “built” lately and straight-up tell you: some of it is complete garbage. It’s messy. It’s inefficient. It breaks every best-practice rule in the book. I hate saying “Look at this thing I wrote” because I didn’t. I also hate the term “I Vibe’d it” – I’m using “Build” for now.

But you know what? It works.

And for me… sometimes that’s enough.

That’s the dirty little secret I don’t see a lot of people admitting out loud in this whole vibe-coding wave. We’re out here describing what we want in plain English, hitting enter, and watching magic happen. No hand-written algorithms. Just vibe. And yeah, it gets stuff done faster than I ever could on my own. But it also leaves me feeling like a hack. Like I’m riding a rocket ship I didn’t build and don’t fully understand. Thankfully no human lives on the line here.

And then I look at my friends.

Take the great John Capobianco. That guy is constantly vibing entire projects into existence. He’s out there building VibeOps communities, spinning up AI agents that feel alive, turning weekends into prototypes that actually ship. I watch what he and others are doing and I’m genuinely inspired… but I’m also hit with that punch-to-the-gut feeling: “Damn, the world just moved on again.” I finally get comfortable with GitHub Copilot and suddenly everyone’s talking about the next thing. I learn one new trick and three more drop that make it feel obsolete. It’s exhausting. Insert GooberClaw or whatever new “Claw” is out this week, I have yet to even try John’s NetClaw because frankly some of those things I just don’t trust – but somehow in a dumb way I trust my own vibe coded stuff – that’s pretty dumb.

I’m not alone in this. NetworkChuck dropped a video the other day called “I kind of hate AI… and it almost made me quit YouTube.” I watched the whole thing and just nodded the entire time. He straight-up says it: it’s a love-hate situation. The pace is relentless. Even on sabbatical he couldn’t escape it – AI was in his feed, in his conversations, in his head 24/7. He felt paralyzed. He hated that he hated it. I felt that in my bones. You nailed it Chuck.

Here’s the thing nobody talks about enough: this speed is creating real stress and anxiety.

Reaching out ot my AI Friends to help me research this one…. University studies back it up. A 2020 study by Rosenstein, Raghu, and Porter at UC San Diego (published at SIGCSE ’20) found that 57% of computer science students experience frequent impostor feelings – 52% of men and a whopping 71% of women. That was before the AI explosion. Fast-forward to 2025-2026 and a new Eastern Washington University survey of 1,000 workers shows that people using AI daily are the most likely to report regular impostor syndrome (30%). Another Ernst & Young study found 66% of employees are anxious about falling behind if they don’t use AI, and 65% are stressed about not knowing how to use it ethically.

There’s even a term for it now – technostress – and research in PMC shows AI-generated technostress indirectly tanks quality of life through spikes in negative emotions. We’re all feeling it: the pressure to keep up, the fear that if you blink you’re obsolete, the quiet voice whispering “you’re not a real builder.”

I feel that voice every single day.

But here’s the flip side – the reason I’m still writing this series and still showing up.

Vibe coding isn’t just about perfect code. It’s about democratizing building. It’s about taking non-devs like me and saying, “You don’t need to be fluent in three languages and have 10 years of LeetCode problems solved. You can describe the problem, iterate fast, and ship something that moves the needle.” It turns coders into faster builders and non-coders into innovators who never would have started.

I’m also taking steps to get others on the train and mentor others, my mentors have recently said to me “I won’t be here for ever, it’s time you start doing more” <– I am embracing this. Just yesterday a colleague talked to me about how he wished he could build something – I asked him if he had tried, then showed him 60 seconds of what’s possible – he was excited to start, and went on his way. Maybe I am more ahead than I think – there’s that impostor thing again.

Some of my code is garbage? Cool. It solved the problem in my lab in an afternoon instead of a week. John is out there vibing entire platforms into existence? Amazing – I’ll keep learning from him and cheering him on. NetworkChuck is honest about the hate part? Respect – it makes the love feel more real. These experts inspire me.

So yeah… I feel behind. I feel insecure. I feel the anxiety of “doing well” in a world that doesn’t slow down. But I’m also still here, still experimenting, still believing that “it works” is a valid starting point when you’re a systems guy who never planned on being a builder.

If you’re a non-dev reading this and you feel the same way – welcome to the club. If you’re a dev watching the vibe-coders and feeling a bit of whiplash – you’re not alone either. If you think the stuff we are building is bloated trash — you are 90% right – sometimes.

Drop a comment. Tell me where you’re at. Are you riding the wave or white-knuckling it? Let’s keep the conversation real.

At the end of the day, vibe coding was never about being the best coder in the room.

It was about giving more of us a seat at the builder’s table.

And I’m still showing up to that table – garbage code and all, still feeling out of place, still feeling behind.

(And if you’re new here, catch up on the AI series: Vibe Coding with GitHub Copilot and OpenClaw: The Passion-Driven AI Agent.)