Look at the interfaces of the newest AI coding tools and you'll notice something strange: the code is disappearing. Claude Code lives in a terminal: the agent edits your files and prints what it changed, but that printout is display, not a door — you can't click into the file it just wrote. The desktop chat apps are the same pattern one step up: in Claude Desktop and ChatGPT Desktop running Codex, created and edited code appears as rendered blocks and diffs inside a conversation, with no direct interaction with the written file — to actually open or touch it, you leave for a separate editor. Devin presents itself as an engineer you manage through chat. Google's Antigravity puts you in an "agent manager" view. And the newest vibe-coding platforms go furthest of all, burying the code view behind toggles or gating it entirely. The industry has quietly converged on one pattern: you talk to the agent; you see pictures of your code; the files themselves live somewhere else.
Cortex is agentic-first too — the autonomous loop is its engine. But there is one pattern I refused from day one: hiding your code. In Cortex, your working project is always right there — full file tree, project-wide search, and any file one click from open in a real Monaco editor, editable by hand at any moment. No mode switch. No "open in IDE" button. This article is about why that decision matters more than it looks.
The AI writes the code. It's still your product.
Here's the mental model I built Cortex around. When an employee writes code for your company, they wrote it — but it's your product. You'd never accept "trust me, it works" without the ability to open the files, read them, and change them. Nobody would run a company where the codebase is visible only through a chat summary of what the employee says they did.
An AI agent is exactly that employee. It types faster than you, costs tokens instead of salary — but the output belongs to you, ships under your name, and fails on your customers. Vibe coding changes who types; it doesn't change who owns. And when you're the owner, two things are permanently your job:
- Thinking. What should this do? What does the output need to look like? What instruction gets the agent there? That's where your time and money actually go now — the code is the cheap part.
- Verification. The agent's loop verifies with tests and exit codes; a reviewer model audits the diff. But the final auditor is you — and you can't audit what you can't see.
The mental connection problem
There's a real cost to chat-only interfaces that nobody prices in: you lose your mental map of the codebase. When every change arrives as a summarized diff in a conversation, you stop knowing where things live, how modules relate, what that one config file actually contains. Three weeks in, the project is genuinely yours on paper and genuinely a stranger's in your head. The research community already measures the result — only 29% of developers trust AI-generated code, and unreviewed AI code carries measurably more vulnerabilities. Distance breeds both the distrust and the defects.
The fix isn't reading every line the agent writes — that defeats the point of agents. The fix is keeping the connection cheap: when something feels off, you click the file and read it. When a change is small, you make it yourself instead of writing a paragraph of instructions. When the agent finishes, you spot-check the two files that matter. Each of those actions takes seconds in an IDE and a context-switch in a chat tool — and actions that cost a context-switch simply stop happening.
How Cortex holds both
Agentic-first and code-always aren't opposites; they're two halves of one workflow:
- Hand off like a manager. Describe the goal; the loop plans, edits, runs, and verifies — with budgets and safety gates doing their job.
- See everything, always. The Explorer shows your real file tree live (files the agent creates appear as it creates them). Project-wide search — by name, text, or meaning — is always available.
- One click to the code. Any file opens instantly in the Monaco editor — the same editing core developers already know — with syntax highlighting, multi-tab, and full manual editing. Verify what needs verifying; change what needs changing; never ask permission from the interface.
- No switching. Chat, agent activity, file tree, editor, and terminal are one screen. The agent's diffs are clickable; the files they touch are open-able; your edits and its edits land in the same place.
In other words: Cortex assumes the AI writes most of the code, and assumes you'll want your hands on some of it — every session, without friction. The newest wave of vibe-coding tools increasingly treats direct code access as an advanced feature to hide. I think that's exactly backwards: the less code you personally type, the more the one-click path to reading it matters.
The ambition
My ambition for Cortex is simple to state: the AI writes your code, and you never lose the connection to it. You bring the thinking — what to build, how it should behave, what "done" means. The agent brings the typing, the iteration, the test runs. And between you and it sits not a chat transcript, but your actual codebase — searchable, clickable, editable, yours. That's the difference between delegating your work and surrendering it.
See how it feels in practice: download Cortex for Windows, hand the agent a task, and mid-run, click any file it's touching. It's your code. You should never have to switch apps to look at it.