So, the last couple of days have been a bit of a whirlwind in developerland. I wanted to take a moment to write down what I’ve seen, and what I think it means, because these aren’t small updates. This is a shift in how we build, browse, and write code.
Let’s start with the first big one: OpenAI launched something called ChatGPT Atlas, and no, it’s not just another tab inside ChatGPT. It’s a browser. A whole new take on what it means to interact with the web. But instead of tabs and bookmarks, it’s built around memory, intent, and AI agents that actually do things on your behalf. You’ve got a side pane that can summarise what you’re looking at, dig deeper, compare different sources, fill in forms for you, and even remember what you’ve done before.
Now, I’ve seen plenty of AI assistants over the years that promised to “change everything”; most of them just added a chat bubble somewhere and called it a day. This one’s different. The context window is persistent across the browser. It remembers where you’ve been, what you’re trying to do, and it can act, with your permission, inside the browser. Think about that for a moment. The browser, the most passive layer in your tech stack, just got a memory and a task queue.
This is not just another Chrome clone with a gimmick. This will mess with how we think about frontend design. Because if users now live in a browser that understands their behaviour and nudges them proactively, it means that UX design is no longer just about reducing clicks — it’s about how well your product plays with an AI sitting next to your user. Forget onboarding wizards. The assistant is the onboarding. Your documentation is now part of a real-time dialogue.
From a dev team’s perspective, this means rethinking what we track, what we expose, and how we structure the product to be read by another agent rather than just a human. You suddenly have a second interface layer you didn’t ask for. And you’re going to have to account for it.
The second big update hit closer to home for developers: Cursor 2.0 dropped, and with it came their new coding model, Composer 1, and a completely rethought interface for working with multiple agents in parallel. If you haven’t used Cursor yet, it’s basically VS Code rebuilt from scratch around an AI pair programmer. Except now, it’s not one AI; it’s a whole squad of agents working on your repo at once. They read your context, write code, suggest changes, refactor, review… and now, compete with each other to produce the best outcome. I've tried it intensively since yesterday and it's at least on par with Claude-4.5-sonnet. Maybe even better. With Cursors "Plan" mode, this really is a great leap forward.
That last bit is interesting. They’ve leaned into the idea that multiple agents solving the same problem will often produce better results than just one. Cursor now lets them do just that, like pair programming, but on steroids. You don’t pick the best solution anymore. The system does. Or at least tries to.
Composer, their in-house model, is apparently 4x faster than anything else they’ve tried, which is impressive. But more importantly, it’s been trained specifically for low-latency, high-context software work. In practice, that means you’re not waiting around 90 seconds for an answer that’s 60% helpful. It’s fast, and it knows the shape of your repo.
Also, they’ve added an embedded browser inside the IDE, so you’re not jumping between tools anymore. You inspect, debug, test, and code; all in the same view. And you can see exactly what the agents changed across the whole codebase, finally solving that annoying game of file-hop you usually play during PR reviews.
For starters, development is becoming less about “who can write the best code” and more about who can guide, validate, and integrate the best agent output. And that’s a big shift. Developers will need to stop thinking like code typists and start acting like orchestrators. That means your onboarding, your reviews, your pair programming culture – all of that needs to evolve.
It also means that “move fast and break things” is getting a dangerous upgrade. If agents are writing code faster than your team can review it, you’re one misfire away from disaster. So while it’s tempting to throw this into your process and double velocity, remember what The CTO Playbook always says: Tooling must evolve with process, not replace it.
Now more than ever, your tech org needs to ask some hard questions:
These aren’t hypotheticals anymore. They’re the questions you need to solve if you’re rolling this stuff out in a real dev environment. Because whether you like it or not, your developers are already using these tools at night, on side projects, or right inside your main branch when you’re not looking.
Both of these updates, Atlas and Cursor 2.0, are signs that we’re not just adding AI to our tools anymore. We’re rewriting the interfaces entirely.
As someone leading tech teams, your job isn’t to stay ahead of every trend. But it is your job to spot the moments when infrastructure changes. This is one of those moments.
If you’re trying to make sense of how to roll out AI-powered development safely and effectively, or how to structure your dev process around agents instead of individuals, shoot me a message.
For a deeper discussion on building AI-assisted developer workflows, team orchestration, or agile leadership in this new tooling era, feel free to reach out via email at [email protected] or visit ctotmc.com. I’m also happy to connect via LinkedIn at linkedin.com/in/robertmejlero.
You’ll need a different playbook for this. (Glad I just updated it!)
Robert Mejlerö
CTO | Founder of The Mejlerö Company
Author of The CTO Playbook
We help companies with their technology, providing CTO-services and Product Management. Trusted for our CTO-services, we work with both startups and established businesses in the Nordics, Switzerland and US.
We are a Swiss Company (LLC) based in 
Switzerland.