Updates to my AI Stack since November. Three shifts changing everything

A year ago, my AI stack was about tools (even 2-months ago!). Now it's about how work gets decomposed, directed, and executed in real time while you're doing it.

Not about better features. It's about better thinking.

Not everything has changed. I'm still using Claude, Gemini, Comet, NotebookLM, Nano Banana, Descript, GPTs, Skills. Some I've doubled down on, some I've stopped over-optimising.

But three shifts stand out. These are the ones that genuinely changed my behaviour, not just my tool list.

What actually changed most is how I decompose work.

This isn't about approaching work as tasks anymore. Work is approached as jobs that need to be structured differently depending on what I'm trying to solve.

A marketing content job breaks down differently than an operations job, which breaks down differently than a data analysis job. And how you involve agents shifts with each one.

Here's the framework for how I think about this now:

Define the job → Identify the micro-tasks → Match agents to tasks → Run in parallel → Review and judge

Everything else ladders into that.

For content creation and marketing:

Example:

Suddenly structure is provided to think from. This isn't a polished output by any means, just raw, honest thinking extracted and shaped into something actually useful. Parallel thinking catches things sequential analysis misses.

This is where the real efficiency lives, and it looks nothing like the automation fantasy or building apps with code.

My old workflow was:

Context lived in my head, not in the system. Work got fragmented across tabs and every new chat was basically “start again, but faster”.

Claude Code changes the unit of work. In the browser, the unit is a chat session. In Claude Code, the unit is a workspace.

Claude Code is Claude running inside the terminal with direct access to your local files. That sounds basic, but it flips everything:

1) Your files become the memory (not the chat)

In the browser, context is temporary. It fills up, degrades, and disappears behind scrollback. Even Projects still trap context inside the product.

In Claude Code, the folder is the source of truth. Your drafts, notes, transcripts, datasets, rubrics, and prior work sit beside the work you’re doing now. Claude can read them without you uploading anything. When you update a file, the system updates. No re-pasting “here’s the context again” like a goldfish reset. That alone kills context rot.

2) You stop doing sessions and start building systems

The browser makes you feel productive because you finish the one task quickly. But when you come back a month later, you’re hunting for the prompt, re-uploading files, rebuilding the flow.

Claude Code lets you turn a repeat workflow into a reusable command. The first time you do something, it’s manual. The second time, it becomes a slash command.

Example structure (the pattern matters more than the topic):

Now “new competitor” or “new feature” isn’t six new chats. It’s one line added to a file and one command. This creates compounding leverage.

3) Parallel agents fix the two big problems: speed and degradation

In chat-based workflows, you work sequentially. One thing at a time. And the longer you go, the more the context window fills and the more the quality drops. You’ve felt that “third competitor analysis is worse than the first” effect.

Claude Code can spin up multiple agents at once. Each agent has its own fresh context window, using the same framework files. So output quality stays consistent at scale. Five tasks, ten tasks, fifteen tasks: same method, same thoroughness. That’s not only faster but significantly more reliable.

4) Portability is the advantage

Projects and chats live inside Anthropic. Your workflow becomes vendor-specific. Claude Code flips that too. If your context and outputs are just local markdown files and folders, you can swap the model later without rebuilding the entire system. Getting closer to the markdown file is the key.

What it looks like in practice

Everything stays grounded in the same material. No copy-paste. No context loss.

This is the major shift that's taken place in my work. Not “better answers”. A better operating system for work.

What if the browser wasn't supposed to be where you find information?

For a while, agentic browsers felt like a neat trick. Cool to watch research happen in the background but not something you'd actually build your day around.

That's changed, and it isn't because the agents got smarter. It's because my work in the browser shifted from being a separate tool to a system for automating specific actions within the work I'm already doing.

The pattern I use now looks like this:

Here's an explanation + demo of ways of working.

I outline the narrative structure and key points in a Claude pane. While I'm shaping the story, I open Google Slides in the second pane. Then I tell Comet in the third pane to populate slide one: "Put the title here. Add these three bullets. Format the text box this way."

If Comet puts text in the wrong box, I tell it. It fixes it immediately. One correction, it learns the pattern for the next slide. No regenerating the whole deck. No bulldozed branding. No formatting refactoring.

Here's the thing: tools like Gamma move fast. But they destroy hierarchy, branding, and spacing. You end up spending more time undoing their choices than thinking about the narrative. That's not faster. It's illusion of speed.

Comet moves slightly slower on first pass. But because it takes direct, corrective action within the actual interface, I reach a finished outcome faster. Time shifts from refactoring to thinking. That's the real trade-off.

But here's where it gets genuinely useful: I'm not working on one slide at a time anymore.

I'm running ten versions of this workflow in parallel.

Each slide gets its own agent working on different angles. One explores a different narrative structure. One tests a different set of examples. One tries a different tone. While those ten versions run alongside each other, I'm reviewing, judging, pulling the best pieces.

Here's another example with the browser building a Google Form without me touching the mouse.

These patterns can apply across many different tasks and jobs. For example, outbound work:

No longer are we tab switching or copy-pasting research into email templates. The agent acts directly on what I need.

The browser stopped being where I look for things. It became where all work happens.

The last pattern that ties this together is genuinely different.

You build tools that don't exist until you need them, then discard them when you're done.

Most tools we use are designed for general problems. They're bloated with features you don't need, they take setup time, and they create long-term maintenance debt.

What if instead you built a tool for the specific job at hand, used it once, then threw it away?

That's ephemeral UI in practice.

Example: I wanted to practise a talk.

The tool was simple: an interviewing interface that asked me questions on my talk topic. As I answered, it adapted based on what I said. It recorded audio. At the end, it transcribed and scored my answers against source material I uploaded about the topic.

That tool existed for one purpose: help me think through my talk by being questioned on it. After that session it was discarded. I can always spin this back up when needed.

Zooming out, this changes everything about how we build capability. Instead of buying tools and adapting ourselves to them, we build tools that adapt to us.

Google AI Studio makes this possible because you're not coding. You describe what you need and the interface generator creates it. No infrastructure setup. No deployment complexity. Describe → build → use → discard.

This changes economics. Instead of maintaining one tool serving many purposes, you maintain many micro-tools built for specific moments. The sum is faster than the alternative.

What's most important to remember is that you don't have one "AI workflow" anymore. You have a workflow that changes shape based on the job.

Most jobs need combinations of all three.

Sara Davison articulated something that shifted how I think about everything: "we used to define value by execution. Now value comes from design, direction, and evaluation. You're not grinding toward completion. You're deciding what needs to happen, spinning up agents to do it, reviewing output, deciding what matters".

People expected agents to take 30-step processes and execute them perfectly. That was never the point. And it's not how this works.

The best outcomes with AI come from non-determinism. Back-and-forth, exploration, constraint and correction.

Also, hallucinations aren't the core problem. Vague thinking is.

We want absolute clarity, minimal thinking, maximum creativity, and guaranteed accuracy. You can't have all four without guardrails. Actually can't.

AI isn't the silver bullet we imagined. It's a copilot that rewards people who know where they're going.

Here's the thing: what's actually shifted is how quickly you can explore. You run ten versions of something in parallel. You decompose a job into smaller tasks and have agents work on each simultaneously. You test approaches instead of committing to one path.

This is the shift in thinking that happens as you ingrain these tools into your ways of working.

The gap in twelve months won't be between people who use Claude and people who don't. It'll be between people who redesigned how work actually gets done and people still grinding through the old model.

The winners will:

Everyone else will still open one doc and hope they execute properly. That's not a tool gap. That's a thinking gap, and it widens every month.

My recommendations:

Pick one job you do regularly. Redesign it using one of these three approaches.