DEV Community: Dorien

Your AI Coding Agent Is Working in a Folder You Can't See

Dorien — Tue, 11 Aug 2026 07:38:47 +0000

Here's a workflow that has quietly become normal in 2026: you open a terminal, type claude (or fire up Grok, Kimi, or whatever agent you run), and start delegating. The agent reads files, edits files, writes files. You supervise.

And here's the part nobody talks about: the supervision experience is terrible.

Your agent lives in a terminal window. Your files live in Finder, or your editor's sidebar. Your agent's output (plans, reports, summaries, README updates) lands on disk as Markdown that Finder renders as a wall of # and *. So you sit there alt-tabbing between a terminal, a file browser, and an editor, playing air traffic controller for a process that's supposed to be saving you time.

I spent months doing exactly this before admitting the tooling was wrong. Not the agent... the agent is great. The environment around the agent was designed in 2001.

Full disclosure before we go further: I'm the developer of the app this article ends with. But the problem is real regardless of whose tool you use to fix it, so let's start there.

The three frictions of agentic coding

Friction 1: the cd dance. Your agent works in the terminal's current directory. Your attention works wherever you're browsing. These drift apart constantly. You're looking at components/auth/ in your file browser while your agent session sits in the repo root, and every task starts with re-aiming it: "look at the file in components/auth/...". You are a human path-resolver.

Friction 2: invisible changes. The agent says "I've updated the config and refactored the handler." Did it? What does it look like now? Your options: ask the agent to cat the file (burning tokens to see your own disk), switch to your editor and navigate to it, or trust blindly. None of these are glancing at the file, which is what you actually want.

Friction 3: the Markdown pile. Agents narrate in Markdown. Plans, migration guides, analysis reports, CHANGELOGs — my projects have accumulated dozens of agent-written .md files. These are documents, written to be read. Every mainstream file manager shows them as raw markup, because in 2001 nobody's disk was full of Markdown.

None of these frictions is huge. But you hit each of them dozens of times per session, and agentic coding is supposed to be about eliminating exactly this kind of overhead.

What the environment should do instead

Work backwards from the workflow and the requirements are obvious:

The terminal and the file browser should share a location. Browse to a folder, and the shell — and therefore your agent — is already there. Point at things by navigating to them, not by typing paths into a prompt.

Files should be readable the moment you select them. Markdown as a formatted document. CSV as a grid. Code with syntax highlighting. Zero clicks, zero app switches. You're reviewing an agent's work, not archaeology.

Small fixes should happen in place. The agent left a wrong value in a config? Click, fix, save. Round-tripping through the agent ("please change line 14...") for a two-character edit is absurd; so is opening an IDE for it.

And the loop should end where it starts: see the git status, commit, push —> from the same window.

This is not a radical vision. It's roughly what KDE's Dolphin gave Linux users twenty years ago (minus the AI, the previews, and git). It just never existed on macOS.

So I built it

Iruka (イルカ — "dolphin" in Japanese, named for its inspiration) is a native Swift file manager for macOS built around exactly this loop. The agentic workflow in practice:

I browse to a project. The integrated terminal is already there — no cd, ever. I type claude and start a session. As I click around the project, the session's context and my visual context stay glued together: when I say "fix the bug in this file," this file means the one I'm looking at.

While the agent works, I watch files change in the preview pane next to the terminal - rendered Markdown, highlighted code, CSV grids. When it writes MIGRATION-PLAN.md, I read it as a document, immediately, without leaving the window.

One detail I'm particularly happy with: follow-mode pauses itself during long-running commands. If the agent is mid-task (or you're mid-npm install), navigating around won't yank the shell's directory out from under it — Iruka detects the running process, pauses the sync, and offers to resume when it's done. This is the feature that makes the synced terminal actually usable with agents rather than just a demo trick; a stray click can't corrupt a 20-minute session.

When the agent's done: git status is right there in the browser — branch, staged files — and I commit and push without touching another app. If something's slightly off, the Edit button in the preview pane fixes it in place. If I want to verify a change landed everywhere, Power Search greps the whole tree with regex, no indexing.

The whole supervision loop (aim, delegate, watch, read, fix, commit) happens on one continuous surface.

And it extends past your own machine. Saved SSH hosts connect from the sidebar with one click —> the terminal opens already connected, so running an agent session on a remote server is the same workflow, minus typing IPs from memory. Right-click any local file to SCP it over; mount S3, SFTP (even as sudo), or WebDAV and browse them like local folders.

To be clear, none of this rides on a stripped-down browser: Iruka is a full Finder replacement first — dual-pane browsing, batch rename with preview, an operations queue for big transfers, list/column/icon views, symlink support. The agent workflow is what's new; the file manager underneath is complete.

The honest caveats

Iruka is not an IDE and doesn't try to be — for serious editing you'll still want your editor, and the in-place editing is deliberately scoped to quick fixes. It's macOS-only (14+, native Swift, no Electron), and it's paid: $19.99 one-time, no subscription, with a 30-day trial and no credit card. If your agent workflow lives entirely inside VS Code with an extension, you may not need any of this. Mine never did. I think in folders and shells, and if you've read this far, you probably do too.

The roadmap is community-driven through GitHub Discussions. Several shipped features came straight from user requests, and "make it better for agent sessions" is currently the loudest theme.

Agents got a generational upgrade in the last two years. The room they work in didn't. It's time.

macOS Never Got the File Manager Developers Deserved. So I Built It.

Dorien — Wed, 15 Jul 2026 13:15:43 +0000

Here is what my developer workflow looked like for fifteen years:

Navigate to a folder in the file browser. Switch to terminal. cd to the same folder I'm already looking at.

Find a file I want to preview. Hit Space. Looks good. Want to edit it. Open VS Code. Navigate to the file again.

Need to SSH somewhere. Open Terminal. Type the IP I can never remember. Check my notes. Retype it.

I tried Path Finder — and it genuinely is better than Finder, better views, dual pane, real shortcuts. But it didn't fix any of those things. Neither did ForkLift. Neither did anything else.

So I built something that did.

Where the Idea Came From

Years ago, before I switched to macOS, I used KDE's Dolphin on Linux. Dolphin had — and still has — one feature that I've never been able to forget: the terminal follows you. Browse to a folder in the UI and the shell is already there. No cd. No clipboard gymnastics. You're just there.

That's it. That's the feature. It sounds small. It is not small.

When I switched to Mac, I spent years looking for something that did this. Nothing did. Path Finder was the closest — genuinely powerful in some ways, dual pane, lots of options — but the terminal panel sits there statically, indifferent to where you navigate. ForkLift is an excellent SFTP client pretending to be a file manager. Everything else I tried had the same gap.

So eventually I stopped looking and started building.

I called it Iruka — イルカ, dolphin in Japanese, a nod to where the idea started. But Iruka isn't a port of Dolphin. It isn't even a tribute. It's what I think a file manager for macOS developers should actually look like in 2026, built from scratch in Swift, native all the way down. And honestly? It has things Dolphin never had.

What It Does

The terminal follows you. Everywhere.

Browse to any folder in Iruka and the integrated terminal is already pointing there. Click around, the shell comes with you. This works exactly the way your brain expects it to.

There's one smart addition beyond what Dolphin does: if you're running a long command — a build, npm install, a test suite — the terminal automatically pauses the follow behaviour so you don't interrupt it with a stray directory change. A banner appears when the command finishes so you can re-enable with one click. No babysitting required.

I use this constantly with Claude Code. I'm in the file browser, I navigate to a component, I switch to the terminal — it's already there. I ask Claude to look at a file. It's already in the right directory. The whole context switch that used to take five seconds now takes zero.

URL bar with tab autocomplete

The path bar is a real navigation tool, not a read-only label. Click it, start typing, hit Tab. It works the way your shell does. If you think in paths you'll be very fast here.

Click the path bar, type a partial path, hit Tab. The terminal below is already in the same folder.

File previews that are actually rendered

Select a file. See it properly:

Markdown: full GFM rendering — headings, code blocks, tables, blockquotes, inline formatting. Not a QuickLook passthrough. Actual rendering with real typography.
CSV: a proper grid. Bold header row, alternating row shading, scrollable in both axes. Not a wall of commas.
Code: syntax highlighting across 60+ languages. Python, TypeScript, Rust, Go, SQL, Terraform, Swift, whatever you work in.
Everything else: Quick Look for images, PDFs, video.

Path Finder and ForkLift both lean on QuickLook for previews. QuickLook doesn't do syntax highlighting. It doesn't render CSV as a grid. Iruka has its own renderer, which means it can do things QuickLook can't.

Rendered Markdown preview on the right:

Syntax highlighted code previews:

Edit files directly in the preview pane

Any text or code file gets an Edit button. Click it, make your change, save. Auto-saves after 1.5 seconds of inactivity, supports ⌘S, shows a Saved / Unsaved / Saving indicator.

This isn't a replacement for your editor. It's for the times you're scanning files and you spot a problem — a typo in a config, a wrong value in a .env, a stray console.log — and you want to fix it without opening another application. The distance from "I see the problem" to "the problem is fixed" is one click.

Top right shows edit button to directly edit any text-based files:
" width="800" height="528">

One-click SSH

Save your remote servers — host, user, port, key path — and connect from the sidebar with a single click. The terminal opens already connected. That's it.

If you manage more than two or three servers you know how much of your life goes into typing and re-typing connection strings. This ends that.

Save a server once. Connect from the sidebar with one click. No more typing IPs from memory.

SCP file transfer

Right-click any file, send it to a remote host. Or pull files from a remote. The UI handles the details. You get the file transfer workflow you'd otherwise have to open a separate application for.

Dual pane

Two folder panes side by side. Drag files between them. This is standard on Linux file managers and was never added to Finder. Iruka has it. Use it for comparing directories, reorganising projects, moving files between locations without losing your place.

Power Search

Search file contents — not just names. Write a grep pattern or a regex, filter by type, extension, or date, and see results across your whole file tree instantly. No indexing required.

Cloud mounts

Mount S3 buckets, SFTP servers, and WebDAV shares as folders and browse them the same way you browse local storage. Your AWS bucket looks like a folder on your desk.

Batch rename

Select a group of files, define a pattern, preview every change before applying. No guessing, no undo required.

Operations queue

Copy and move operations run in a live queue with real-time progress. Large transfers don't block you from continuing to work.

Why Native Matters

There's a reason I built this in Swift rather than reaching for Electron.

Electron apps start slowly, use hundreds of megabytes of RAM for things that should use tens, and feel subtly wrong on macOS — the scrolling, the fonts, the keyboard shortcuts — because they're running inside a web browser, and web browsers are not macOS apps.

Iruka starts in under a second. It uses native macOS frameworks, which means Spotlight finds it, system keyboard shortcuts work, it respects your system appearance, and it integrates with the OS the way macOS apps are supposed to. If you've used Path Finder you know what "heavy and dated" feels like. This is the opposite of that.

The Part Where I Tell You to Try It

Iruka is at iruka.dorienherremans.com. 30-day free trial, no credit card. macOS 14 (Sonoma) or later. Universal binary — Apple Silicon and Intel.

If you try it and something is missing or broken, the GitHub Discussions board is at github.com/dorienh/iruka-releases/discussions. I read every post. Several features in recent releases came directly from user suggestions — that's genuinely how I want this to keep working.

I built this because I spent years being frustrated by a gap that shouldn't exist. A native, fast, powerful file manager for people who live in terminals and codebases. The one macOS should have had a long time ago.

If you've been making peace with Finder, you don't have to anymore.