I Built Claude Cowork Before Anthropic. Here’s the Tension Every Builder Faces Today.
→ Preface
I loathe the hustlers flooding the internet with claims of cloning billion-dollar apps in a day. This piece isn't about how fast you can build with AI. Much to the contrary, it's about how pointless that mindset becomes in the age of AI. Speed without direction leads nowhere. The interesting question isn't how quickly can I ship. It's what does it mean when anyone can ship quickly.
The Convergence
January 12th, 2026. Anthropic announces Claude Cowork. Ten days of work.
December 17th, 2025. I had built the same thing. Six hours.
Why?
I spent all of 2024 convincing people, mostly non-coders, to use Cursor. The premise was simple: making things with nothing but natural language was now possible. Product Managers. Designers. Researchers. Sales. Marketers. Anyone who participated in the making could now be empowered to bring their ideas to reality independently. No waiting for engineering. No translation through tickets and specs.
It was a hard sell early on. An IDE isn't for everybody. But the people who showed resilience got it immediately. The rest eventually followed.
When Claude Code launched, it was instant love—for me. But the same people I had spent a year converting to Cursor were only just beginning to find their footing. And the terminal was too intimidating. Too much jargon. Too developer-focused. All that power, locked behind a blinking cursor in a black rectangle. The keyboard-first metaphor was intimidating.
"I've never opened the terminal in my life. I just find this too overwhelming."
That was the feedback. Not the model isn't good enough. Not the features are missing. The interface itself was the barrier.
So it made sense to abstract it away. I opened Claude Code and built what is, essentially, Claude Cowork.
The same conceptual product—a GUI wrapper that translates terminal interactions into an assistant paradigm, designed to unlock agentic capability for people who've never touched a command line.
I called it Flow. A Tauri desktop app with multi-agent orchestration, PTY session management, a 1:1 translation layer that renders Claude Code output as both raw terminal and friendly cards. The architecture, the interaction patterns, even some of the specific features—plan visualization, task tracking, context management—mirror what Anthropic shipped.
This is not a complaint about being scooped. I had no intention of launching Flow. Wrappers, no matter how elegant, rarely provide durable value. Undoubtedly, the best people to launch Claude Cowork are the good folks at Anthropic. The leverage lives at the model layer, not the presentation layer. I knew this going in.
But the convergence itself is the story.
What does it mean when an individual, working passively over a holiday, independently arrives at the same solution as a frontier AI lab with hundreds of engineers and billions in capital?
It means the distance between individual capability and institutional capability has collapsed.
And that collapse changes everything about who gets to shape infrastructure.
What I Built
Flow: a Tauri desktop application wrapping Claude Code in a multi-agent orchestration layer.
The Architecture
The Rust backend uses `portable-pty` to spawn and manage multiple PTY sessions. One per agent. With lifecycle management, I/O streaming, and 32KB output buffers for reconnection. The frontend is vanilla JavaScript with Vite, rendering terminals via xterm.js with WebGL in a Tauri webview.
Note: I do NOT know Rust.
The core principle: 1:1 translation. Both the raw terminal view and the friendly card-based UI read from the same PTY buffer and write to the same PTY input. Claude Code's behavior is never modified. Only its presentation changes. Regex pattern matching on the output stream translates terminal content into cards: thinking states, file operations, responses, interactive prompts.
The terminal remains the source of truth. Flow is a lens.
The Design
I used the Mac OS 9.2 aesthetic, inspired by Ryo Lu's RyoOS. Retro interfaces communicate permission. They say this is friendly, you're allowed to play here.
Intro page similar to the Warp terminal (which I love) inspired by Mac OS 9.2
The left pane: Project Grounding.
Plan visualization organizes Claude.md and Plan.md. (Note: I moved Skills.md to the Assistant panel on the right)
Task tracking with bidirectional updates.
File structure for spatial orientation.
Left pane lets users build orientation. Right pane lets them interact with Claude Code.
The center pane: the actual Terminal.
Deliberately visible. I didn't want users abstracted from reality. The goal was translation, not concealment. I didn’t have any plans of maintaining this product over time. I wanted people to get to Claude Code sooner. Flow was meant to be a stepping stone to the real thing.
The terminal output in the middle remains unchanged allowed user to observe Claude Code output.
The right pane: the Flow translation.
The same terminal output, stripped of bash syntax, rendered as conversational cards. Simple instructions, interactive elements, the assistant paradigm everyone already understands.
Simple animations even translate the serendipitous thinking states.
Tabs for multi-agent orchestration. The swarm concept was too abstract for non-coders—they constantly confused "tasks" with "agents." This is probably why Claude Cowork does not yet have this at launch. The team is probably trying to figure out how to make this developer concept universally applicable to all.
I think the answer is Tabs. Tabs are universal. Each tab becomes a separate Claude Code session within the same project. Parallelism made navigable through familiar metaphor.
It goes without saying, the folks on the Claude Cowork team have to use an existing MacOS app surface with Cowork embedded inside it making it a bit tricky, while I had a lot of freedom with the interaction paradigm since this was a standalone app.
Users can use Tabs to run agents in parallel. Claude Cowork doesn’t quite have this yet.
Users can interact with the AskUserQuestion tool using a simple click-based behavior.
Each card gives users a dynamic and interactive option in the right sidebar.
Flow also has Skills letting users to quickly pick from an existing list or make their own. Flow also lets users use the dropdown as the Model Picker. Finally, Flow lets users curate a Task list, which can also be managed by Claude Code letting bi-directional alignment possible.
The only thing I probably spent a lot of time on was mapping all of Claude Code responses. This was the only tricky part of the whole thing. The rest was basically a well-grounded context engineered exchange with little to no frustration.
Some mermaid diagrams to give you the full picture of what I built.
When Structures Turn Into Shackles
The point of this essay isn't to showcase Flow. That's a footnote. It isn't to celebrate arriving at the same problem as a frontier lab independently. Anthropic is best suited to build Claude Cowork. I'm genuinely excited to see where they take it beyond the Research Preview.
The reason I chose this topic as the opening essay of future(memo) in 2026 is to explore the tension every builder is currently facing across our industry. I frame this tension across three pillars.
1. Models, not Tools
We are witnessing SaaS collapse unto itself.
As models (Opus 4.5, GPT 5.2 etc.) become genuinely capable at most general tasks, the fundamental need to open a specialized tool begins to dissolve. I don't need Skyscanner. I don't need Word. I don't need Powerpoint. I don't even need Cursor or even a Browser now for most things.
I can spin up Claude Code or GitHub Copilot CLI, fire a swarm of agents to find the best flights to Tokyo, research my next article by reading my Substack, build a presentation, research camera gear, and ship a feature—all between my first coffee and lunch. The ritual of opening a specialized tool/application, clicking, dragging, scrolling—replaced by my effectiveness at orchestrating agents toward outcomes.
Obviously, my expertise in this space lets me curate higher output. But it's only a matter of time before steering models becomes pervasive among people who don't have advanced degrees in AI. Today, I open Claude Code to do most of my work while I focus on thinking.
This leaves builders of tools asking themselves: what are we even building, and will it survive where this new paradigm is headed?
Certain tools still pull me in—Lightroom for its specific capabilities, Microsoft Teams for coordination that requires presence. But the gravitational pull weakens with every model release. It's only a matter of time where one might not ever need to pay for a software license ever again. Everything is well on its way to becoming headless (markdown or web-based) and the agents you orchestrate understand these protocols intimately to be able to do the work for you; without the need for a specialized tool to do things anymore. The Anthropic bet of “code becomes the source of truth” now only needs a thin layer to interface with the model to generate incredible results.
2. Outcomes, not Artifacts
At the advent of the PC, humans began relying on software to replace the tedious mechanics of office work. Memos became emails. Physical contracts became Word docs. Accounting books became Excel files. Giant slideshows became Powerpoint decks. The physical office migrated to the digital Microsoft Office.
But one thing didn't change: coordination.
Whether you were constructing the Empire State Building, engineering the Porsche 911, or building Zune—you still needed people to align, communicate, and move together. That required constant back-and-forth between disciplines and teams. And that back-and-forth centered the organization around files: Word docs, Excel sheets, Powerpoint decks, emails, meeting transcripts, GitHub Issues. The artifacts we created for the purposes of efficient coordination became the epicenter of the workplace.
Not anymore.
In a world where a single person can build something end-to-end and launch it, the epicenter shifts from artifacts produced to manage coordination, to outcomes that can now be independently achieved. You don't need to coordinate with hundreds of people. Your agents can spin up, orchestrate the work, iterate on feedback—while you focus solely on the outcome you want to achieve.
The artifact is no longer the unit of work. The outcome is.
This leaves the people who built careers around artifacts—the deck-makers, the spec-writers, the process-designers, the code-writers—asking themselves: what is my role when coordination costs collapse to zero?
Is it even meaningful to produce these artifacts if I can independently reach the finish line—for my company, my org, or myself—without convincing an army of people to move with me?
3. Vision, not Execution
Back in 2006 when I first visited Google in Mountain View I remember seeing this giant graffiti in the lobby of one of their offices that read, “Execution beats Vision every day of the week, and twice on a Sunday.” The quote obviously emphasizing the importance of heads down execution to drive forward innovation.
This is the final inversion.
For decades, the bottleneck was execution. You could have the most brilliant vision in the world, but without the ability to build, or the resources to pay smart people who could, your vision remained trapped in your head. Execution was scarce, expensive, slow. Entire industries existed to provide it. Organizations were structured around it.
Now execution is approaching abundance. It now basically comes down to the compute one can afford.
Large, multi-billion-dollar companies remain stuck employing thousands of people still operating in an old model. One that assumes expensive coordination costs. Archaic structures that will be decimated once individuals realize what they can produce independently, without the need to work in globally distributed teams. You see this across every large organization operating on products used by billions: countless cycles spent making marginal improvements to systems that are rapidly becoming obsolete. Like fireflies in a jar, teams build one feature after another, held back by legacy architectures, trying to justify their own existence while scrambling to ship an AI assistant into their product just to keep up with market demand.
The new scarcity is knowing what to build and why. But most employees across large enterprises are focused on keeping the lights on.
The new bottleneck is vision. The ability to see what should exist before it does, to recognize which problems matter, to have taste about what constitutes a good solution. Not just a me-too product portfolio.
This is disorienting for builders who constructed their identities around execution capability. Product Managers who run large teams. Designers who own complex experiences. Technical architects who craft intricate systems. I can code. I can design. I can ship. These were meaningful differentiators. Now everyone can code, through models. Everyone can design, through models. Everyone can ship, through models. I'd go as far as arguing you don't need to know any of the three to make what you want today.
What remains is the question you start with. The direction you choose. The judgment about what's worth making.
This leaves executors asking themselves: what differentiates me when anyone can execute?
Vision was always valuable. But it was downstream of execution. Without the ability to realize it, vision was just daydreaming. Now vision is upstream of everything. Execution follows from it, nearly automatically.
The builders who thrive will be the ones who cultivate vision deliberately. The entire industry is scrambling to keep pace with the breakneck speed of AI innovation. We still don't have clear winners. But the answer cannot, and will not, be found in the ideas of today. We need an entirely different mindset to truly realize the potential of AI. That's okay. Technology shifts rarely start with answers. We're still in the toy era.
Tools. Artifacts. Execution. These are the structures most of the tech industry was built upon. They're the shackles of today.
The Year Ahead
I chose the Flow-Claude Cowork story to open the future(memo) in 2026 because I felt this had the perfect underlying tension everyone is feeling about AI now. It surfaces the questions that matter most for builders today:
What do we build when models subsume tools?
What is work when outcomes replace artifacts?
What differentiates builders when execution is democratized?
Who shapes infrastructure when individuals can build what institutions build?
What does an organization even look like on the other side of this?
These are questions I ask myself daily. What do I build that will uniquely allow me to create value in this world?
We're at the beginning of something. I have a strong opinion around all these topics I can’t wait to explore and write about. That's what future(memo) will explore this year. Not the hype. Not the fear. Rather, the substance of what's emerging.
There's a lot of ground to cover. Thank you for your support.
