Vibe coding made me faster at building. It also made my desktop a complete mess.

Vibe coding moved the bottleneck somewhere I didn't expect

I've been building much more heavily with AI lately, and one thing surprised me: as the coding agents got better, I spent less time worrying about the code itself and more time trying to keep track of everything around it.

A normal session might leave me with a screenshot showing a UI bug, another screenshot showing what I actually wanted, a useful answer buried halfway up a Claude conversation, a color from a reference site, a documentation link, a generated image in Downloads, and a bit of copy that I wanted to preserve before asking the agent to change anything else.

None of those things felt important enough to organize properly because most of them would be irrelevant twenty minutes later, but they were important enough that losing one meant interrupting the flow of the work and going hunting for it again.

At first I assumed this was just me having a messy desktop. Eventually I realized it was a consequence of how my role in the development loop had changed.

The agent has context, but so do I

A lot of the discussion around AI coding is understandably about giving the agent better context: repository structure, specs, project rules, architecture, documentation, previous decisions, and everything else it needs to make sensible changes.

But there seems to be another layer of context that belongs to the human steering the agent.

If I'm fixing a UI problem, I might have six pieces of information in front of me, but perhaps only two actually belong in the next prompt. One might eventually become permanent project documentation, another is useful only so I can compare the next build myself, and three can disappear as soon as the bug is fixed.

I don't necessarily want the agent to remember all of that.

I need to remember it long enough to decide what the agent should see.

That distinction has become more important for me as the tools have improved, because the faster the implementation happens, the more of my attention shifts toward choosing what matters, checking whether the result is actually correct, and deciding what information should shape the next iteration.

My first solution was to leave everything open

For a while, my system was basically browser tabs, Finder windows, and optimism.

The reference stayed open because I might need it again. The AI conversation stayed open because there was a good answer somewhere above. Screenshots collected on the desktop, useful commands occasionally went into Notes, and Downloads became a temporary database whose indexing system consisted mainly of remembering what time I generated something.

It worked well enough that I never thought seriously about it, but there was a constant tax in the form of tiny retrieval problems: which screenshot was the correct one, where did that error come from, which generated file was the good version, what was the color I copied before copying the URL, and what had I told the agent two iterations ago that produced the better result?

The irony is that AI reduced the amount of code I had to carry in my head while increasing the amount of working material I was carrying everywhere else.

I think context engineering has a human side

There is a lot of good advice now about writing specs, keeping agent conversations focused, maintaining project rules, and not throwing irrelevant information into a model's context window, but before I can give an agent clean context I still have to keep hold of the messy material from which I decide what "clean context" actually is.

That material tends to be temporary by nature. Screenshots, copied errors, prompts, URLs, reference images, files, and little fragments of code might matter intensely for the next fifteen minutes and then have almost no value once the task is finished.

I ended up building a small Mac shelf app called Tansei around this problem because I wanted somewhere to keep that temporary working context visible without pretending that every useful thing deserved a permanent home, but the more interesting question to me is whether other people have hit the same problem.

The faster coding agents become, the more I suspect the human bottleneck shifts from producing the implementation toward maintaining orientation while the implementation changes underneath you.

How are you handling this in your own AI coding workflow?

If you're using Claude Code, Cursor, Codex, Replit, Lovable, or something else, where do you keep the screenshots, errors, references, prompts, and files that matter for the current task but probably won't matter tomorrow?

Do you put everything into the agent, keep a scratchpad, use a dedicated tool, or are browser tabs and the desktop still doing most of the work?