AI Work Needs a New Interface

More of my work is starting as a ramble.

That sounds messy because it is messy.

I talk into a microphone for a few minutes, dump half-formed thoughts into Codex, and expect the system to figure out what kind of work I am actually asking for.

Sometimes that means changing a product.

Sometimes it means drafting a blog post.

Sometimes it means updating durable context so a future agent remembers the lesson.

Sometimes it means all three.

That is the part that feels new.

The work no longer starts as cleanly as:

Open the right project, edit the right file, run the right command.

It starts more like:

Here is what I am thinking. Figure out where this belongs.

That has implications for Codex, Claude, and any AI-first work tool.

I do not think the current interface is the final shape.

The project is not always the starting point

Projects still matter.

Repos matter. Folders matter. Files matter. Tests matter. Deploy targets matter. Permissions matter. At some point the work has to land somewhere real.

But the starting point is changing.

When I am working with an AI agent, my thought does not always begin inside the correct project boundary.

I might be looking at a landing page in one repo and realize the product positioning should become a blog post.

I might be editing a blog post and realize the underlying idea belongs in my agent instructions.

I might be talking through a product idea and realize part of it is a code change, part of it is a public essay, and part of it is a private note for future me.

That is not one project.

That is a work stream.

And right now, most tools still make me pick the project first.

That makes sense for file safety. It makes less sense for thought capture.

Voice makes the mismatch obvious

Typing usually forces structure.

Voice does not.

When I dictate into an AI tool, I am not always giving it a clean task. I am giving it the state of my head.

That state might contain:

A product critique
A UI change
A blog post idea
A public positioning point
A durable preference
A future product feature
A private concern
A specific file edit hidden inside a broader thought

In the old workflow, I would split all of that myself.

One note goes to the product repo.

One note goes to the website.

One note goes to agent context.

One note becomes a tweet.

One note waits.

With AI agents, I expect the system to help with that split.

That is not just a nicer inbox. It is a different interface model.

I want an agent that is always there

The shape I keep imagining is simple.

There is an AI agent available everywhere in the workspace.

Maybe it sits in the bottom-right corner. Maybe it is pinned in the top-left. Maybe it is a command layer that follows me across projects. The exact placement matters less than the behavior.

The behavior is:

I can talk to it from wherever I am, and it can help route the work.

Not route in a vague productivity sense.

Route concretely:

This belongs in the current repo.
This belongs in the website repo.
This belongs in durable memory.
This should become a draft, not a published post.
This needs a task list before implementation.
This should not be public.
This should wait because the current project is not the right scope.

That is what I want from Codex.

Not only better code generation.

A better work interface.

We are moving away from clicking through tools

I do not think the future of work is clicking through fifteen links, opening the right folder, finding the right file, typing the perfect prompt, and manually moving the result somewhere else.

Some of that will still exist.

But more of the work will start with talking.

That means the interface has to account for messy human input.

People are going to say things like:

This landing page feels too corporate. Actually, that reminds me of a bigger point about trust in AI products. Maybe that is a blog post. Also make sure future agents remember this preference.

That is one thought.

But it implies multiple artifacts.

Current tools can help if you already know where to put the thought.

The next step is helping decide where the thought belongs.

Projects still matter, but they need a new role

I do not think projects go away.

They probably become more important, because they are where verification happens.

A product repo has tests, local instructions, build commands, environment constraints, and deployment rules.

A website repo has content structure, image conventions, publishing rules, and tone expectations.

A context repo has durable preferences, safety rules, and memory boundaries.

Those boundaries are useful.

The mistake is treating them as the only way to begin.

In an AI-first workflow, the thought can start outside the project.

Then the agent should route it into the right project with the right level of caution.

That makes projects destinations, not always the front door.

Context routing is the missing layer

The product idea underneath this is context routing.

Not prompt engineering.

Not file search.

Not a chat sidebar that only answers questions about the current page.

Context routing.

The agent should understand the shape of the thought and decide what kind of action it implies.

Some examples:

A product critique becomes a scoped UI change.
The reason behind the critique becomes a blog post.
A repeated preference becomes an update to durable instructions.
A temporary idea becomes a note, not a feature.
A public thought gets cleaned up for publishing.
A private thought stays private.
A cross-repo task is split into separate, verified changes.

This is where current project models feel thin.

They are good at containing work.

They are not always good at receiving messy intent.

This is bigger than Codex

I am thinking about this because I am using Codex heavily.

But the idea is bigger than Codex.

Claude needs some version of it.

Cursor needs some version of it.

Notion, Linear, Slack, Gmail, Google Docs, GitHub, and every AI-first work surface probably need some version of it.

If AI agents are going to sit inside real work, they need to understand that the user is often not asking a single app-specific question.

They are trying to move a thought through a system.

The product has to help the thought become the right artifact.

That is the job.

The agent should ask what kind of artifact this is

One simple version of this interface could be an artifact router.

After I ramble, the agent might say:

I see three artifacts here: a product change, a blog draft, and a durable preference update.

Then it could show a compact plan:

Update the landing page in the product repo.
Draft a blog post in the website repo.
Update agent context in the context repo.

That would be much closer to how the work actually feels.

It would also make the agent safer.

Instead of blindly acting inside the current folder, it would name the destination first.

That matters.

AI agents are powerful enough now that the risk is not just bad output.

The risk is misplaced output.

Good work in the wrong place still creates a mess.

The point

AI is changing the unit of work.

It used to be easier to think in projects:

I am in this repo, doing this task.

Now more work starts as intent:

I have a thought, and I need the system to figure out what kind of work this is.

That does not make projects obsolete.

It makes project boundaries more important after the thought is understood.

The interface I want is not just a better chat box.

It is an always-available agent that can listen to a messy thought, identify the artifacts, route them to the right place, and keep the boundaries clear.

The thought can be messy.

The routing cannot be.