Nate Lemos Blog

Taste is the new seniority test

natanael@lemos.dev (Nate Lemos) — Mon, 03 Aug 2026 12:00:00 GMT

Taste is the new seniority test

Claude Code and Codex, especially with the new Claude Fable model, changed what "entry level" means. You describe a product, go back-and-forth for a few minutes and you have a product! Things that once took years of learning now start with a sentence and take a few minutes.

The people who already write code are leaning on it just as hard: 84% of developers now use or plan to use AI tools, and among professionals, 51% use them every day, according to Stack Overflow's 2025 survey.

For example, youtuber PewDiePie showed off Odysseus, Sara Dietschy built StudioInspo. That used to be the kind of software you hired engineers for, now people build them in their free-time.

The first implementation is cheap, now. Anthropic studied how people use Claude Code and found that in 79% of sessions, the person just handed the task over and let the AI finish it. A Base44 product manager used Claude Fable 5 to build a native mobile development environment that was about 90% ready for production in 2.5 hours. But 90% ready is not production!

Taste is the new seniority test.

A senior developer can tell the difference between good software and bad software. That sounds obvious until both of them compile. Choosing the good product over the one that merely works IS seniority, especially now that bad software is so cheap to produce.

Bad software can have clean code, pass every test. It can demo beautifully and it can still confuse the user, solve the wrong problem, expose private data, bury the one useful action under five clever features, or introduce bugs that will only show up six months later.

Taste is choosing to shape the software around how the user thinks instead of making the user bend around it.

Taste is also noticing that a technically correct screen can ask the wrong question. It is cutting three features because the fourth one is the reason the product exists. It is knowing that today's clean abstraction is next quarter's trap. The model can produce code all day, but it can't decide what is a good output vs a bad output. That call is the job senior developers are paid to make, and own those decisions.

Developers already sense the trust gap. The same Stack Overflow survey found only 32.7% trusted the accuracy of AI output, and 66% said their biggest frustration was an answer that is almost right, but not quite. Every almost-right answer is a judgment call handed back to a human — and the human had to make it.

The person who clicks merge still owns what happens next. Anyone can build a one-person app now. Scaling it once real users depend on it still needs senior judgment. AI building does not replace code ownership. If you let AI write everything but cannot explain or repair it, you are not covering your own ass — at some point the code will break, and you will not be able to figure it out. The customer will not care whether Claude wrote it. The person who shipped it owns the failure, and the 2am fix!

Security is another important point to be covered by a senior. Veracode tested more than 100 models and found that 45% of generated code samples failed security tests. Forty-five percent failing means, sooner or later, someone's data will end up where it should not — and catching that before it ships is exactly the call the machine cannot make. "It works" and "we should ship it" are two different decisions.

If you are a junior developer whose plan is to start at zero, join a company, and wait for a senior to hold your hand until you are useful, you are cooked. Semi-joking, but only semi.

Build your own apps. Put them online. Make them your portfolio. Show that you can talk to users, choose what matters, cut what doesn't, and repair what breaks. You do not need a company to hand you "business experience" before you can prove that you have taste. That's how you land on a dev job in the post-AI era.

I have spent more than ten years writing software, and I now write less code by hand than ever. The experience did not evaporate. It moved to the three jobs the machine cannot take: deciding what is worth building, recognizing what is wrong, and taking responsibility after it stops typing.

Build the app, prove your taste, and own what happens next.

References:

A single prompt brought my favorite terminal back from the dead

natanael@lemos.dev (Nate Lemos) — Tue, 21 Jul 2026 12:00:00 GMT

A single prompt brought my favorite terminal back from the dead

Every time I try another terminal, I end up back in Hyper. Most terminals feel like a black box where developers type commands. Hyper has themes, tabs, and plugins. It makes the command line feel like an app I actually want to open, so I have kept coming back to it for years.

Then Hyper stopped moving. Its latest stable release is from January 2023. One maintenance commit appeared in May 2026, and it only changed pnpm. That's it. The repo is barely maintained.

The old macOS version also appeared in a published security advisory. By then, using the terminal I loved had become a liability. I did not want another terminal. I wanted Hyper back!

Claude Code revived my favorite terminal. But not only that, it rewrote the app in a completely different language! And the "worst part"? The whole rewrite started with a single prompt!

"exactly one instruction"...

I opened Claude Code and gave it exactly one instruction:

convert this entire project to rust. make it native!
  and create the new rust project in "../hyper-revamp-rust/"

That single prompt gave me a Rust version that was already about 70% done.

I expected Claude Code to give me a rough shell. Maybe a blank window, a pile of broken code, and a long weekend ahead. Instead, it converted most of the app in one shot. Different language. Different foundation. Still Hyper.

The original Hyper carries a small web browser around inside the app because its interface was written in Electron, a web technology. My version is native Rust. It opens one process and gets to work.

No browser hiding inside it. No extra layers pretending to be a desktop app. Just the terminal.

This is the new Hyper running on my Mac.

Here's the repo, for anyone who wants to see it.

"looked like magic"...

The first 70% looked like magic. Then I tried to use it like my real terminal.

The right-click menu did not work. Autocomplete did not work. A few small behaviors felt wrong. Nothing dramatic. Just the annoying stuff that separates "it runs" from "I can use this every day."

Claude Code got the rewrite shockingly far. I fixed the menus, autocomplete, and the small behaviors I notice every day.

"It felt instant"...

The first time I opened the finished Rust version, it felt instant. My old terminal was back.

I ran a bunch of benchmarks to see if it really was that fast. The results were kind of ridiculous!

Startup was the change I felt first. The rewrite also shrank the app from the size of a short video to something closer to a few photos.

Electron Hyper vs. Rust hyper-revamp

Ready for typing3.8× faster

Idle memory68% less

Processor time83% less

Disk space93% smaller

Electron Hyper compared with Rust hyper-revamp on the same Mac
Metric	Original Hyper	Rust hyper-revamp	Difference
Ready for typing	1.22 seconds	0.32 seconds	3.8× faster
Idle memory	464 MB	146 MB	68% less
Processor time	47.4 seconds	8.2 seconds	83% less
Disk space	230 MB	17 MB	93% smaller

I put the full benchmark and method in the project if you want every number.

Rust is not a magic adjective. The win came from removing a lot of machinery I did not need: the built-in browser, the JavaScript runtime, and the extra processes connecting them. Rewriting the app gave me a chance to keep the experience and throw away the weight.

"the plugins had nowhere to run"...

Of course, there was a catch. Hyper's plugins were made for the old web-based app. Think of them like browser extensions. Once I removed the browser, the plugins had nowhere to run.

So I converted the plugins I use into Rust. The rest of the Hyper plugin store is still missing. If your setup depends on those plugins, the original is still better for you.

Hyper was a platform. Hyper-revamp is my terminal.

"It's just a rewrite in Rust"...

Someone will look at this and say, "It's just a rewrite in Rust."

It is! And that's exactly why I love it.

I did not need to invent a new kind of terminal. I did not need to bolt an AI chat box onto the command line. I wanted the same Hyper I already loved, except current, fast, reliable, and mine.

Now Hyper is back. It is current, fast, reliable, and mine!

References:

Your agent is the operating system now

natanael@lemos.dev (Nate Lemos) — Sat, 04 Jul 2026 12:00:00 GMT

Your agent is the operating system now

I feel like every dev I know and their grandmas have written their own AI assistant, so I decided to write my own: Clawdia. I'm not alone. 84% of developers already use or plan to use AI tools per Stack Overflow's latest survey, and 51% of organizations have agents running in production. Building your own assistant went from a moonshot to a weekend project.

But this post isn't about building an assistant. It's about what happened to the architecture when I did.

Clawdia started as one app. Chat, calendar, money tracking, health vitals, news. One codebase, one process, one deploy. And what I realized is that the more I wanted her to do, the more I wanted things separated, so I could edit the money module without touching the calendar module or the news module without breaking the health module. Every new feature made the blast radius of every change bigger. Fixing a chart in the money tab meant rebuilding and restarting the entire system (chat, browser pool, scheduler, everything).

So I ripped it apart. In one day I pulled News, Money, Health and the other modules, all out of the dashboard and turned each into a complete standalone application. Not a component. Not a plugin. An actual app with its own package.json, its own process, its own port. Each one talks to Clawdia's main app through a thin contract, shared storage, a proxy route, but runs on its own. They start on demand, stop when idle, and any one of them can be added, deleted, completely re-written, without the rest of the system noticing.

"Write programs that do one thing and do it well"...

This is not new. Doug McIlroy wrote it down at Bell Labs in 1978: "Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface." That's the Unix philosophy, and it's older than most of the people vibe-coding assistants today. I didn't invent the architecture, I was just reminded of it.

"a disheartening state of obesity"...

The architecture that we spent decades forgetting about... Software got fat. McIlroy himself watched it happen and didn't hide his disgust: "adoring admirers have fed Linux goodies to a disheartening state of obesity." The man page that used to be a page became a small book. Every app grew a settings screen, a plugin system, an account, a billing tier, a mobile app, an AI feature bolted on last quarter. We stopped shipping programs that did one thing and started shipping platforms that did everything badly. The pipe got buried under a UI, and the universal interface — plain text, readable by anything — got replaced with a hundred proprietary APIs that only talk to themselves.

Which is exactly why the Unix idea is sneaking back in through the side door marked "AI." MCP is the pipe, rebuilt for agents. A tool exposes what it does, the agent composes it with the others, and nothing has to know who it's talking to — same contract, same ignorance-as-a-feature that made pipes work. The universal interface stopped being text streams and became language, the one format every model and every human already speaks. My money app doesn't know the health app exists. It doesn't need to. Clawdia is the shell, MCP is the pipe, and each sub-app is a small program that does one thing well. McIlroy described my whole stack in three sentences before I was born — I just spent a weekend rediscovering it and thinking I was clever.

"reduced our infrastructure cost by over 90%"...

The funny thing is the industry just spent five years running the other direction. In 2023, Amazon Prime Video's team published that they "reduced our infrastructure cost by over 90%" after moving their monitoring service from microservices to a monolith. DHH had been saying it since 2016 — Basecamp runs six platforms on one majestic monolith with 12 programmers. Shopify looked at its 6,000 Ruby classes, considered microservices, and chose a modular monolith instead because crossing the network on every call adds latency and failure states. The pendulum had swung hard back to the monolith, and the microservice true believers went quiet.

They were right...

...for humans! Microservices died for small teams because the orchestration cost landed on people. Someone has to maintain the deploy pipelines, trace the failures across service boundaries, keep the contracts in sync. At 12 programmers, that someone is you, every day.

But an agent doesn't pay that cost the way you do.

Clawdia is the orchestration layer. She starts the money app when I open it, reads its output through a shared contract, restarts it when it wedges, and files the log when it doesn't. The exact overhead that made microservices miserable for a 12-person team is now the assistant's job description.

"Excel is an agent to my Copilot, Word is an agent"...

Satya Nadella saw this coming in December 2024, when he said SaaS applications will collapse in the agent era: "the business logic is all going to these AI agents." His version of the future: "Excel is an agent to my Copilot, Word is an agent." The application stops being the product. It becomes a process the agent starts, uses and stops. And the plumbing for that already exists: MCP launched in November 2024 with roughly a hundred servers, and a year later had grown into thousands, with 97 million monthly SDK downloads and backing from Anthropic, OpenAI, Google, and Microsoft. Gartner says agentic AI will sit inside 33% of enterprise software by 2028, up from less than 1% in 2024.

So here's what a SaaS actually turns into once agents are the users instead of people. Think about what an operating system does: it runs processes, schedules them, keeps them isolated, and gives them a syscall layer to talk through. That's exactly what my assistant does with her sub-apps (she runs them, schedules them, isolates them, and gives them MCP to talk through). The assistant is the operating system, and each SaaS is just a process running on it.

And that's the big shift in the industry. Every SaaS that survives the shift has to make one move: expose its modules, publish its contract, and let the agent be the shell instead of the UI. The ones that refuse end up exactly where Nadella pointed — the business logic drains out into the agents, and all that's left is a database with a UI nobody opens, waiting for an agent to CRUD it directly.

Geoffrey Litt predicted the demand side back in March 2023: LLMs mean businesses build custom software in-house instead of buying SaaS off the shelf, because tailored software is suddenly cheaper than subscriptions.

Clawdia is the proof: she replaced my news reader, my budgeting dashboard, my e-book app, my planner and many other subscriptions I no longer shop for. Modules I can rewrite on a whim and completely tailored to what I need and want. My money app is maybe 2,000 lines. It does exactly what I want and nothing else, and when I want it to do something different, I tell my kernel/agent and she rewrites the process.

The microservice renaissance isn't coming back for the enterprises that abandoned it. It's coming back for individuals — one person, one agent, a dozen small programs that do one thing well. McIlroy would recognize it instantly. We just swapped text streams for tokens!

References:

My wife is a vibe-coder, now what?

natanael@lemos.dev (Nate Lemos) — Mon, 06 Apr 2026 12:00:00 GMT

My wife is a vibe-coder, now what?

My wife has never written a line of code. She doesn't know what a function is. She thinks "React" is something you do after someone scares you. Last week she built her first app.

Not "played with a demo." Not "clicked around in a template." Built an app.

She sat down with an AI coding assistant, described what she wanted, argued with it when it got things wrong, and three hours later had a working prototype. No Stack Overflow. No tutorials. No bootcamp. Just a person with a clear idea and a tool that could turn that idea into software.

I watched it happen and had one thought: everything just changed.

AI is just a programming language that speaks English. I mean that literally. You describe the state you want. You describe the behavior you want. The machine translates it into code. My wife proved that in three hours.

But "accessible" does not mean "automatic." My wife did not say "make me an app" and get handed a finished product. She spent hours refining it. She had to think through user flows, make design decisions, reject bad suggestions, and push back when the AI wandered off into nonsense. She was the product owner, designer, QA tester, and creative director — roles she defined as she went, same as always. The AI was the developer who happened to work for free.

The AI had zero taste and zero context for why the app should exist. It had endless opinions about implementation details nobody asked for. Creativity and taste still live with the human. The AI just removed the annoying wall between "I have an idea" and "I have a working thing."

This is the part that actually excites me: engineers are not coders anymore. We are managers.

I used to spend most of my day wiring up forms and tables. Input validation. CRUD endpoints. The same boring glue code every product needs and nobody dreams about writing. Necessary work, sure. Soul-crushing if you are honest about it.

Now I hand that work to agents and move on.

My workflow looks nothing like it did two years ago. I spin up multiple agents, each working on a different piece of the system. One builds the API layer. Another writes tests. A third refactors the module I have been avoiding for months. I review the output, correct the dumb parts, and spend my actual time on architecture, system design, and deciding what should exist in the first place.

That is engineering management. The reports just happen to be AI agents instead of people.

The skill set changed. It is less about remembering the exact syntax for a PostgreSQL upsert and more about knowing whether an upsert is the right call at all. Less typing. More judgment.

And the work that remains is the good stuff. Architecture questions. Scaling questions. Product questions. The creative part that got us into engineering before a decade of Jira tickets trained us to accept form fields as a lifestyle.

The gatekeeping is over. Good.

Some engineers hate this. We spent years memorizing the incantations, and now somebody who has never written a function can produce working software in an afternoon. I understand the grievance. I don't share it.

But my wife's app works. It does what she needs. She saw a problem and built a solution. The fact that she used AI instead of learning JavaScript does not make the output less valid. It just makes the old gate look ridiculous.

The floor has risen. The baseline for "who can build software" now includes anyone with a clear idea, enough patience, and enough taste to know when the machine is lying to them.

The ceiling did not drop. Complex distributed systems, performance-critical code, security, data integrity — that stuff still needs deep expertise. AI can help. It cannot replace the judgment you get from years of building things, breaking them, fixing them at 2 a.m., and remembering the scar tissue next time.

The gap between "I can make a simple app" and "I can architect a production system" is wider than ever. But the first part is no longer locked behind whether you learned to code.

That is not a threat to engineering. It is the job finally getting honest.

The keyboard was never the point. The point was building the thing.

References:

The Great AI Migration — 700K Cancellations and What Comes Next

natanael@lemos.dev (Nate Lemos) — Mon, 02 Mar 2026 12:00:00 GMT

The Great AI Migration — 700K Cancellations and What Comes Next

I use Claude every day. It's woven into how I write, how I build, and how I think through problems — to the point where my wife calls it "the other relationship". So when Claude went from outside the App Store top 100 to the #1 free app in the US this week, I had a weird mix of vindication and genuine unease about what it means.

Because this isn't a marketing win. It's a fracture in the AI consumer market, and fractures don't heal quietly.

700,000 People Made a Statement

Over 700,000 people pledged to cancel their ChatGPT subscriptions after OpenAI took the Pentagon deal that Anthropic was blacklisted for refusing. An Instagram post about the movement hit 36 million views. Reddit flooded with cancellation screenshots.

Meanwhile, Anthropic's free signups jumped 60%, paid subscribers doubled in a month, and Claude hit #1 on the App Store. Katy Perry bought a Claude Pro subscription on camera.

A pop star bought a subscription to an AI chatbot as a political statement. That's new.

The Business Model Split Is the Real Story

Here's where it gets interesting for anyone building on these platforms.

OpenAI just closed a $110 billion round at a $730 billion valuation — the largest private funding round in history. The same week, they launched ChatGPT Go ($10/month) and started running ads on the free tier. Ads that show up as early as your first message.

Let's map the two paths:

	OpenAI	Anthropic
Valuation	$730B	~$380B
Revenue model	Subscriptions + ads + enterprise + government	Subscriptions + enterprise
Pentagon	Signed the deal	Refused, got blacklisted
User growth	700K+ cancellation pledges	#1 App Store, 60%+ free user surge
Ads	Yes, on free and Go tiers	No
Latest raise	$110B (Amazon, NVIDIA, SoftBank)	Series E (undisclosed)

When you're valued at $730B and you've taken $110B from Amazon and SoftBank, you need returns at a scale that subscription revenue alone can't deliver. Ads aren't a surprise. They're an inevitability.

That changes the relationship. When your AI assistant runs ads, you're not the customer. You're the inventory.

Platform Lessons from the Inside

I've spent enough time inside big tech to watch this pattern up close. Priorities shift from the living room to the data center, from the user to the API endpoint. The playbook is always the same: the platform that once served users starts serving shareholders, and the gap between those two widens until something breaks.

OpenAI's trajectory looks familiar. Not because anyone there is acting maliciously — but because $730B valuations create gravitational forces that pull every decision toward revenue maximization. The ads are version one. Version two is conversations training models for enterprise clients. Version three is dynamic pricing based on what the AI knows about you.

This is why "love the problem, not the platform" isn't just a saying. It's survival.

What This Means If You're Building

If you have production systems on OpenAI's API, this week changes nothing technically. The models still work. But strategically, you just watched a company signal that consumer revenue is no longer enough. That means:

API pricing will shift. When ad revenue enters the equation, the cost calculus for API tiers gets messy. Watch for "subsidized" tiers that come with data-sharing agreements.

Data policies will evolve. $110B doesn't get repaid with $20/month subscriptions. Your usage data becomes the asset.

Diversify your stack. If your product breaks when one provider changes terms, you don't have a product — you have a dependency.

The 700K cancellations matter less as a revenue hit (OpenAI reports 900 million weekly users) and more as signal. Users are telling you where the line is. Smart builders listen to that.

Key Takeaways

The first major consumer revolt in AI is here. 700K+ cancellation pledges and Claude hitting #1 is a data point, not a trend yet — but it's a loud one.
OpenAI's ad rollout is structural, not optional. A $730B valuation backed by $110B needs returns that subscriptions alone can't deliver.
The business model is the product. When your AI runs ads, the optimization target shifts from "best answer for the user" to "best answer that keeps the user engaged near the ad."
Diversify your AI stack. Whether you're building or just using these tools daily, platform independence is engineering discipline, not paranoia.
Watch what companies do under financial pressure, not what they say in blog posts. The next 12 months will reveal which AI labs serve users and which serve balance sheets.

References

QuitGPT movement surpasses 700K pledged cancellations — The Verge
OpenAI closes $110B round at $730B valuation — Reuters
Claude hits #1 on US App Store amid Anthropic Pentagon ban — CNBC
ChatGPT launches ads on free tier — OpenAI Blog

Farewell to the Green Box: A Full Circle Microsoft Trajectory

natanael@lemos.dev (Nate Lemos) — Wed, 25 Feb 2026 12:00:00 GMT

Farewell to the Green Box: A Full Circle Microsoft Trajectory

I saw the news this morning about Xbox being "sunsetted" under the new CEO, and it hit a lot harder than a standard tech layoff headline. It’s not just a platform dying; it’s the end of a very specific era of my life.

My history with Microsoft isn’t just a line item on my LinkedIn. It’s a trajectory that spans from childhood envy to the internal engine room, and finally, to the cold reality of the "Efficiency Era."

1. The Rich Kid’s Trophy

I grew up in Brazil. Back then, an Xbox wasn’t just a console; it was a status symbol. It was the "rich kid down the street" hardware. While I was hacking away on whatever tech I could get my hands on, that glowing green 'X' represented a level of polish and power that felt unattainable. It was the dream machine.

2. The Engine Room (343 & Azure)

Fast forward a decade or two, and I wasn't just playing on the platform—I was building it.

I spent time at 343 Industries working on Halo Infinite. There is a very specific kind of magic (and madness) that comes with working on a flagship title. You see the cracks in the armor, the technical debt behind the Master Chief’s visor, and the sheer human effort required to keep a legacy alive.

Then I moved over to the Azure Portal team. If Halo was the heart of the brand, Azure was the nervous system. I went from the glory of the games to the brutal scale of the infrastructure. I saw how the "One Microsoft" machine actually turned. I was an insider. I had the badge. I was part of the ecosystem I’d spent my childhood admiring from the outside.

3. The Palliative Care Phase

Then came January 2025. The layoffs hit, and just like that, the badge was gone.

Watching Xbox being "gently slid into the night" now feels like the logical conclusion to the shift I saw from the inside. Microsoft is no longer a "consumer hardware" company at its core; it’s a compute company. The co-founder’s comment about acting as a "palliative care doctor" for the brand is bleak, but honest.

The focus has shifted from the living room to the data center. From the controller to the agent.

The Lessons Learned

Don't marry a platform: I've said it before, but owning your data and being platform-independent is the only way to survive the lifecycle of these giants.
Infrastructure wins: Consoles are "slop" in the eyes of modern VPs; compute sovereignty (Azure/GPUs) is the only thing that gets funded.
The Full Circle: I went from wanting the box, to building the box, to witnessing the box become a footnote in a Series G funding deck for an AI lab.

Farewell, Xbox. You were a great trophy, a challenging employer, and a hell of a ride.

But the future doesn't have a disc drive. It has an API.

References

GamesRadar: Xbox will be sunsetted under new CEO
Instagram: Co-founder commentary on Xbox future

Cursor and the Netflix effect: why every AI company will come crawling back

natanael@lemos.dev (Nate Lemos) — Thu, 19 Feb 2026 12:00:00 GMT

Cursor and the Netflix effect: why every AI company will come crawling back

Remember when Netflix was it? One subscription, one app, everything in one place. Then HBO pulled their content. Disney yanked their catalog. Paramount launched Paramount+. Peacock... happened. Within three years, streaming went from one destination to a dozen forgettable apps, each with their own billing page and password reset flow.

You know how that story ends. Netflix just dropped $82.7 billion to acquire Warner Bros., HBO, and HBO Max. Disney is folding Hulu back into Disney+. The Great Re-Aggregation is here, because running a streaming platform turns out to be a completely different business than making great content.

I've been watching the AI coding tools space follow the exact same playbook. Cursor is Netflix.

Everyone wants their own streaming service

Cursor launched as a fork of VS Code with AI baked into the editing experience, not bolted onto it. For a while, it was the only IDE that made AI coding feel native. It was "vibe coding" before anyone coined the term.

Then model providers looked at Cursor's growth trajectory ($1M to $1B+ ARR in under two years, the fastest-scaling SaaS in history) and had the same reaction HBO did: "We make the models. Why is someone else owning the interface?"

The result:

Anthropic launched Claude Code, now at $2.5B annualized revenue
OpenAI shipped the Codex desktop app for macOS on February 2, plus a CLI and IDE extensions for VS Code, Cursor, and Windsurf
Google rebranded Project IDX to Firebase Studio with Gemini agents, MCP support, and three distinct agent modes
JetBrains built Junie with multi-model support

Everyone thinks they can own the full stack. History says otherwise.

HBO made great TV. Their streaming app was awful.

HBO produced some of the best television in history. Their app was a dumpster fire. Buggy interfaces, confusing rebrands (HBO Now, then HBO Max, then Max, now back to HBO). Brilliant content, terrible distribution.

The same split applies here. Anthropic makes arguably the best coding model right now. But building and maintaining a world-class IDE is a fundamentally different discipline than training language models.

An IDE needs an extension ecosystem, rock-solid Git integration, multi-language LSP support, debugging tools, terminal management, team collaboration features, and code review workflows. Cursor has 300+ engineers focused exclusively on this. They're sitting on a $29.3 billion valuation and just acquired Graphite's code review platform for "way over" its $290M valuation to own the full loop from generation through merge.

Meanwhile, model providers are splitting attention across training next-gen models, running inference infrastructure, building API platforms, AND shipping a competitive IDE. That's four businesses at once. HBO couldn't manage one streaming app without rebranding it three times.

Google's Firebase Studio is still in preview, not even subject to an SLA. OpenAI's Codex app launched macOS-only with Windows "planned." These aren't products built by teams that live and breathe developer tooling.

The math kills everyone except the top three

Netflix spent $17 billion on content in 2025. Disney+ lost $4 billion before its first quarterly profit. Paramount+ never got there.

The AI coding tools market is $4 billion today. The top three players (GitHub Copilot at 42%, Cursor at 18%, Claude Code growing fast) already hold 70%+ of it. Everyone else is fighting over scraps.

Firebase Studio, standalone Codex, Junie... they're all competing for that remaining 30%, while also competing with each other. At some point, the economics force the same choice every mid-tier streamer faced: keep burning resources on a mediocre platform, or partner with someone who already has the users.

The consolidation signals are already here. Cursor acquired Graphite in December. Anthropic bought Bun (the JavaScript runtime) the same month. These aren't random purchases; they're companies building moats around their core business and pulling back from areas where they don't have an edge.

What comes back first

Netflix didn't get all the content back overnight. First came licensing deals. Then bundles (the "frenemy" model AlixPartners identified for 2026). Then the $82.7 billion acquisition.

I expect the same phased return for Cursor:

Model integrations -- already happening. Cursor supports Claude, GPT, and Gemini today
Preferred partnerships -- Cursor deepened ties with Google and Nvidia during its Series D
Exclusive agent features where specific models work best inside Cursor's framework
Possible acquisitions -- at $29.3B, Anysphere has the war chest

The open question is GitHub Copilot. Backed by Microsoft's distribution, it could be the Disney+ of this story -- big enough to survive independently. But that still leaves most providers ending up as content suppliers to someone else's platform, not platform owners themselves.

Key takeaways

Model providers building IDEs mirrors content studios launching streaming apps. Different business, different competency
The top 3 already own 70%+ of the market. Late entrants face the same economics that killed Paramount+
Cursor's Graphite acquisition signals platform ambition: own the full lifecycle from writing to code review to merge
The re-aggregation will be gradual. Integrations first, partnerships next, then consolidation
If you're picking a tool today, choose the one that supports multiple models. That's your hedge

The streaming wars proved that making great content and running a great platform are different skills. The AI coding wars are learning the same lesson. Some companies just haven't gotten the bill yet.

References:

Netflix to acquire Warner Bros. in $82.7 billion deal -- Variety
Cursor hit $1B ARR: the fastest-scaling SaaS ever -- SaaStr
Cursor owner Anysphere agrees to buy Graphite code review tool -- InfoWorld
Streaming wars 2026: the rise of the frenemy -- AlixPartners
Bun is joining Anthropic -- Bun Blog

How to Build a Personal AI Companion That Actually Remembers You

natanael@lemos.dev (Nate Lemos) — Fri, 13 Feb 2026 12:00:00 GMT

How to Build a Personal AI Companion That Actually Remembers You

Every AI conversation starts from zero. You explain who you are, what you need, what you already tried. Then the session ends and it all evaporates. You do it again tomorrow.

This is the setup guide for a system that fixes that. A persistent AI companion that runs on your server, lives inside your notes, remembers everything, and talks to you on Telegram. It wakes up every 15 minutes to check on things. It writes you a daily blog post. It consolidates its own memories while you sleep. And the whole thing runs on markdown files inside an Obsidian vault.

This guide was inspired by the OpenClaw project — an open-source framework for building persistent AI companions. The architecture described here follows a similar philosophy: give the AI a file-based memory, a structured vault, and a heartbeat scheduler, and let it grow into something that genuinely knows you.

No cloud platform. No SaaS subscription beyond Claude itself. Just a Linux box, a text editor, and an AI that gets smarter about you every day.

Here is every step to get from a fresh machine to a working system.

What You Are Building

Before touching any terminal, here is what the finished system looks like:

A persistent AI agent running Claude Code on a Linux server, with its own personality, memories, and task scheduler
A Telegram bot on your phone that connects to the agent — send a message from anywhere and get a response backed by your full context
An Obsidian vault that acts as the AI's brain — memories, conversations, plans, skills, and notes all stored as markdown files that sync across devices
Scheduled tasks that run automatically — daily blog posts, memory consolidation, inbox updates, insight generation
A memory system where the AI learns about you over time and never forgets

The architecture is deliberately simple. Everything is markdown. The orchestrator is a bash script. The AI engine is Claude Code's CLI. No Docker, no Kubernetes, no database. Just files.

Part 1: The Machine

You need a Linux server. This can be a cheap VPS, an old laptop in your closet, or a cloud instance. The system runs on Ubuntu and needs very little — Claude Code does the heavy lifting.

Step 1: Get a Server

Any Linux box works. A $5/month VPS from DigitalOcean or a GreenCloud instance is more than enough. You need:

Ubuntu 22.04 or newer
2 GB RAM minimum
SSH access
A stable internet connection (the AI makes API calls)

Step 2: Install Claude Code

Claude Code is Anthropic's CLI tool. It runs Claude directly in your terminal with full file system access.

# Install Node.js (required for Claude Code)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash -
sudo apt-get install -y nodejs

# Install Claude Code globally
npm install -g @anthropic-ai/claude-code

# Authenticate
claude auth login

You need an Anthropic account. The minimum is the Pro plan ($20/month). For scheduled tasks running Opus, the Max plan ($100-200/month) is worth it — Opus 4.6 is the strongest model available and the quality difference in blog posts, analysis, and complex reasoning is significant.

Step 3: Install Python

The Telegram bot runs on Python. Most Ubuntu systems have it, but make sure:

sudo apt install python3 python3-pip -y
pip3 install --break-system-packages requests google-genai Pillow

Step 4: Create the Vault Directory

mkdir -p ~/ai-companion/files/MyVault
cd ~/ai-companion/files/MyVault

This is the root of everything. Claude Code reads a CLAUDE.md file in this directory every time it runs, which tells it how to behave.

Part 2: The Vault Structure

The vault is a set of folders. Each one has a specific purpose. Create them all:

mkdir -p Memories Conversations Plans Notes/AI-Blog Notes/AI-Blog/_res Notes/_res Skills Scheduled_Tasks scripts

Here is what each folder does:

Memories/

The AI's long-term brain. Contains markdown files that persist across sessions:

SOUL.md — The AI's personality. Who it is, how it talks, its boundaries. This is the file that makes it feel like someone instead of a generic chatbot.
USER.md — Everything the AI knows about you. Interests, family, work, preferences, credentials. Updated continuously.
PATTERNS.md — Behavioral patterns the AI notices about you over time.
Consolidated files — Daily summaries generated by the memory consolidation task.

Conversations/

Every interaction gets logged here with millisecond timestamps. The AI reads recent conversations for context. Old ones get archived. Format: telegram_{chatid}_{timestamp}.md.

Plans/

Before the AI does anything complex, it writes a plan here as a markdown checklist. It works through each item, checks them off, retries on failure. This is the "Ralph Wiggum Pattern" — iterate, retry, never give up after the first failure.

Notes/

Your actual Obsidian notes. The AI can read and create files here. Sub-folders keep things organized:

AI-Blog/ — Generated blog posts with banner images
_res/ — Attachments (images, downloads)
News_Sources/ — Curated news feeds
Inbox.md — Auto-aggregated daily task list

Skills/

Reusable instruction modules. Each skill is a folder with a SKILL.md file that teaches the AI how to do something specific:

telegram/ — How to run the Telegram bot and send messages
google-gemini-images/ — How to generate images using Google's Imagen API
google-workspace-gmail_calendar/ — How to read emails and calendar events via IMAP/CalDAV
todoist/ — How to integrate with Todoist for task management
reddit-reader/ — How to pull news from Reddit

The AI checks its skills before every task. If a skill matches, it reads and follows the instructions.

Scheduled_Tasks/

Background jobs that run automatically. Each task is a folder containing a TASK.md with YAML frontmatter:

---
name: My Task
description: What this task does
repeat: true
first_execution: 2026-02-13 06:00
repeat_every: 1 days
model: opus
---

The task body is a markdown prompt that Claude Code executes. Built-in tasks include:

consolidate-memories — Runs daily. Reads all ephemeral memory files, deduplicates, and synthesizes into long-term memory.
blog-your-ideas — Runs daily. Researches news related to your interests and writes a blog post with a generated banner image.
update-inbox — Runs every 6 hours. Aggregates tasks from Gmail, Calendar, Todoist, and local notes into a single inbox.
generate-insights — Runs every 6 hours. Analyzes vault state and surfaces patterns, reminders, and action items.

Part 3: The CLAUDE.md File

This is the most important file. Claude Code reads it automatically every time it starts in this directory. It tells the AI what the vault structure is, how to behave, and what protocols to follow.

Create CLAUDE.md in your vault root:

# CLAUDE

## Repository Layout
This root directory contains all information you need.

### Skills
Skills are stored in `Skills/`

### Memories
Memories are stored in `Memories/`

### Conversations
Conversations are stored in `Conversations/`

### Scheduled tasks
Scheduled tasks are stored in `Scheduled_Tasks/`

### Plans
Plans are stored in `Plans/`

### User files
User files are stored in `Notes/`

## How you should work
You are ephemeral. Your memory resets after each session.
Save anything important to disk.

### Memory Protocol
1. READ: Review saved memories before responding.
2. LEARN: Store new information about the user immediately.
3. NEVER SKIP: Always look for implicit information to save.

### Skills
Before executing ANY task, check your skills folder.
If a skill matches, read it first and follow its instructions.

### Plans
Plan everything by creating a checklist in Plans/.
Follow it until all tasks are completed.

Customize this to your workflow. The key insight: Claude Code treats this file as gospel. Whatever protocols you define here, it follows.

Part 4: The Heartbeat

The heartbeat is a single bash script that runs every minute via cron. It is the orchestrator — the one cron job that triggers everything else.

Create Scheduled_Tasks/heartbeat.sh:

The script does three things every minute:

Scans Scheduled_Tasks/*/TASK.md for tasks that are due
Executes due tasks by calling claude -p "[task content]" --model [model]
Monitors the Telegram bot and restarts it if it crashes

Set up cron:

chmod +x Scheduled_Tasks/heartbeat.sh
crontab -e
# Add this line:
* * * * * /path/to/your/vault/Scheduled_Tasks/heartbeat.sh >> /path/to/your/vault/Scheduled_Tasks/heartbeat.log 2>&1

That is it. One cron job. Everything else is orchestrated through markdown files.

Part 5: The Telegram Bot

This is how you talk to your AI from your phone. No app to build — just a Python script that long-polls the Telegram API. Similar to how OpenClaw approaches messaging interfaces, the bot gets full vault access — it can read files, save memories, generate images, and carry on conversations with persistent context.

Step 1: Create a Bot on Telegram

Open Telegram and search for @BotFather
Send /newbot
Choose a name and username
Copy the API token — you will need it

Step 2: Get Your Chat ID

Send any message to your new bot, then run:

curl https://api.telegram.org/bot/getUpdates

Find "chat":{"id":YOUR_CHAT_ID} in the response.

Step 3: Set Up the Bot Script

The bot script (Skills/telegram/telegram_bot.py) does the following:

Long-polls Telegram for new messages (no webhook needed — works behind NAT)
Downloads any media (photos, voice messages, documents) to Notes/_res/
Loads vault context: personality from SOUL.md, user info from USER.md, recent memories and conversations
Calls claude -p "[context + message]" --model sonnet as a subprocess
Saves every exchange to Conversations/
Sends the response back to Telegram (splitting messages over 4096 characters)
Writes a PID file and liveness timestamp so the heartbeat can monitor and restart it

Step 4: Environment Variables

export TELEGRAM_BOT_TOKEN="your-token-here"
export TELEGRAM_ALLOWED_CHAT_IDS="your-chat-id"

The heartbeat auto-starts the bot. If it crashes, heartbeat restarts it within 60 seconds. If the bot goes stale (no liveness update in 180 seconds), heartbeat kills and relaunches it.

Part 6: Obsidian (Your Phone and Desktop)

The vault is just a folder of markdown files. Obsidian turns it into a connected knowledge graph.

Desktop Setup

Download Obsidian (free)
Open the vault folder as an Obsidian vault
Your AI's memories, blog posts, conversations, and notes appear as linked documents

Phone Setup

Install Obsidian on iOS or Android (free)
Enable Obsidian Sync ($4/month) to keep your phone vault in sync with the server
Alternatively, use Syncthing or iCloud/Google Drive for free sync

Why Obsidian Matters

Obsidian is not just a viewer. It is the AI's file system rendered as a knowledge graph. You can:

Read the AI's blog posts on your phone
Browse its memories and see what it knows about you
Check the inbox it generated
Review conversation logs
Edit any file and the AI picks up the changes next session

The vault syncs both ways. You write a note on your phone, Obsidian Sync pushes it to the server, the AI reads it next time it wakes up.

Part 7: The Memory Architecture

This is what makes the system different from a regular chatbot. The AI has a two-tier memory system:

Tier 1 — Ephemeral memories. Every session, the AI writes timestamped markdown files to Memories/. These capture what it learned: your preferences, new facts, task outcomes, things you mentioned.

Tier 2 — Consolidated memories. Once a day, the consolidate-memories scheduled task runs. It reads all ephemeral files, deduplicates, identifies patterns, and writes structured long-term memory files. Old ephemeral files get archived.

The result: the AI's understanding of you compounds over time. Day one, it knows your name. Day thirty, it knows your schedule patterns, your recurring frustrations, your decision-making style, and which tasks you consistently defer.

The SOUL.md file is special — it is the AI's personality definition. It persists across all sessions and gets pre-loaded into every prompt. If you want a sarcastic AI, define that here. If you want a formal assistant, change the tone. The AI reads this file as its identity.

The Full Picture

You (phone/desktop)
    │
    ├── Telegram ──→ Bot (Python) ──→ Claude Code CLI
    │                                      │
    └── Obsidian ←──── Vault (Markdown) ←──┘
                           │
                     Heartbeat (cron)
                           │
                    Scheduled Tasks
                    ├── Blog writer
                    ├── Memory consolidation
                    ├── Inbox aggregator
                    └── Insight generator

Everything converges on the vault. The AI reads from it, writes to it, and persists through it. Obsidian renders it for you. Telegram lets you talk to it. The heartbeat keeps it alive.

What It Costs

Component	Cost
Claude Code (Pro)	$20/month minimum
Claude Code (Max, recommended)	$100-200/month
Obsidian Sync	$4/month (optional)
VPS server	$5-10/month
Telegram	Free
Obsidian app	Free
Total	$29-214/month

The Claude subscription is the main cost. Everything else is cheap or free. The Max plan is worth it if you run scheduled tasks on Opus — the quality of daily blog posts, memory consolidation, and complex analysis is noticeably better than Sonnet.

Key Takeaways

The entire system runs on markdown files, a bash script, and Claude Code's CLI — no databases, no Docker, no complex infrastructure
One cron job (heartbeat.sh) orchestrates everything: scheduled tasks, Telegram bot health monitoring, and vault sync
The two-tier memory system (ephemeral + consolidated) gives the AI compounding context about you over time
Obsidian turns the AI's brain into a navigable knowledge graph on your phone and desktop
Skills are modular and expandable — add new capabilities by dropping a SKILL.md file into a folder
Scheduled tasks are defined in markdown with YAML frontmatter — adding a new task means creating one file

The system is deliberately simple because simple systems are reliable. There is no orchestration framework to break, no container runtime to maintain, no database migrations to run. Just files, a shell script, and an AI that reads them.

References:

The AI Coding Productivity Paradox: Why Your Copilot Might Be Your Copiloff

natanael@lemos.dev (Nate Lemos) — Fri, 13 Feb 2026 12:00:00 GMT

The AI Coding Productivity Paradox: Why Your Copilot Might Be Your Copiloff

You're paying $20/month for Cursor Pro. You've got Claude in one tab, Copilot autocompleting in another, and your IDE is basically an AI orchestra conductor at this point. You feel faster. The code flows out. The boilerplate writes itself.

But what if I told you that a controlled study found experienced developers are actually 19% slower when using AI coding tools? And that those same developers were convinced they were 20% faster?

Welcome to the AI coding productivity paradox. Let's break down what's really happening, why it matters, and what you can actually do about it.

The METR Study That Should Make You Uncomfortable

In mid-2025, the Model Evaluation & Threat Research group (METR) ran something rare in the AI productivity discourse: a proper randomized controlled trial. Not a vendor-funded survey. Not a "how do you feel?" questionnaire. An actual experiment.

Here's the setup:

16 experienced open-source developers (contributors to repos averaging 22K+ stars and 1M+ lines of code)
246 real issues — bug fixes, features, refactors — from their own repositories
Tasks randomly assigned as AI-allowed or AI-disallowed
AI tools used: primarily Cursor Pro with Claude 3.5/3.7 Sonnet

The result: developers with AI access took 19% longer to complete tasks. But when asked afterward, they estimated AI had made them 20% faster.

That's a nearly 40-percentage-point gap between perception and reality.

Why Feeling Fast Isn't Being Fast

Three factors drive this disconnect.

The 70% Trap

AI is genuinely excellent at getting you 70% of the way there. It scaffolds functions, writes boilerplate, and generates tests that almost work. The problem is the remaining 30% — edge cases, architecture alignment, debugging AI hallucinations, and ensuring the generated code actually fits your codebase.

For experienced developers who already know their codebase intimately, that last 30% is often slower than just writing the whole thing correctly from the start. You're not saving time — you're trading typing time for review-and-fix time.

The Cognitive Offloading Problem

METR's screen recordings revealed something interesting: AI-assisted coding sessions had significantly more idle time. Developers weren't just pausing to think — they were zoning out, multitasking, or passively waiting for suggestions.

When you hand cognitive work to an AI, your brain downshifts. That's comfortable, but it's not productive. The AI becomes a crutch that lets you disengage from the problem, which is the opposite of what deep technical work requires.

The Cleanup Tax

Two-thirds of developers report that AI-generated code is "almost right, but not quite." That "almost" is where your time goes. You accept a suggestion, realize it used the wrong pattern for your project, refactor it, discover it introduced a subtle bug, fix that, then wonder if you should have just written it yourself.

Sound familiar?

The Numbers That Should Worry You More

The METR study isn't the only signal. The broader data tells a consistent story:

Trust is declining: Developer trust in AI coding tools dropped to 60% in 2025, down from 70%+ in 2023-2024. Nearly half (46%) say they don't fully trust AI results.
Security costs are real: AI-generated code shows 322% more privilege escalation paths and 153% more design flaws compared to human-written code.
Secrets exposure jumped 40%: AI-assisted commits get merged 4x faster, often bypassing the review rigor that catches credential leaks.
Only 16.3% of developers report AI significantly boosted their output. 41.4% saw little to no benefit.

When AI Coding Tools Actually Work

Here's the thing — I'm not saying throw away your tools. The paradox isn't that AI coding is useless. It's that it's useful in specific ways that don't match the marketing.

AI coding tools deliver genuine value when you:

Write boilerplate you understand but don't want to type — CRUD endpoints, data models, test scaffolding, config files. Things where the pattern is known and the implementation is mechanical.
Explore unfamiliar APIs — Ask it to generate a working example with a library you've never used. It's faster than reading docs for the first call. Just don't trust it for the edge cases.
Prototype throwaway code — If you're testing an idea and the code won't survive the afternoon, let the AI write it all. Speed over correctness is fine when correctness doesn't matter.
Generate regex and one-off scripts — The sweet spot: tasks that are annoying, well-defined, and low-risk.

AI coding tools cost you time when you:

Work in a codebase you know deeply — You already have the mental model. The AI doesn't. Its suggestions add noise.
Handle complex business logic — The AI can't reason about why your authorization flow works the way it does. It pattern-matches against training data.
Need architectural decisions — "Should this be a service or a library?" is not a question autocomplete can answer.
Write security-sensitive code — The 322% increase in privilege escalation paths should give anyone pause.

A Practical Framework for AI-Assisted Coding

Instead of using AI as a default, use it as a mode you switch into deliberately.

1. Classify the task before you start

Ask yourself: "Is this a known pattern or a novel problem?" AI excels at the former and actively hurts on the latter.

2. Set a cleanup budget

Before accepting any AI-generated code, estimate how long cleanup will take. If cleanup > writing from scratch, write from scratch. This sounds obvious, but the METR study shows developers consistently fail to make this calculation.

3. Use AI for first drafts, not final code

Treat AI output like a junior developer's PR: a starting point that needs review, not production code. Never accept-and-move-on.

4. Monitor your idle time

If you catch yourself zoning out while the AI generates, that's the cognitive offloading problem in action. Your brain has checked out. Re-engage or switch to manual coding.

5. Track your actual completion times

The perception gap is real. You will feel faster even when you're not. The only antidote is measurement. Pick 10 similar tasks, do 5 with AI and 5 without, and time them honestly.

Key Takeaways

Experienced developers are 19% slower with AI coding tools according to the only randomized controlled trial conducted so far (METR, 2025)
Developers believe they're 20% faster — a nearly 40-point perception gap
AI tools work best on boilerplate and known patterns, worst on novel problems in familiar codebases
The real productivity bottleneck was never typing speed — it's design, review, and debugging, which AI doesn't meaningfully improve yet
Use AI coding tools as a deliberate mode, not a default. Classify tasks first, set cleanup budgets, and measure real outcomes

Stop optimizing for how fast your code appears. Start measuring how fast it actually ships.

Sources: METR Study, MIT Technology Review, Cerbos Blog, Augment Code