Design Philosophy

Collaboration over automation.
Thinking over typing.
Understanding over speed.

The joy is in the struggle and the solution.
We review every line.
We solve the hard problems.

Simplicity is the ultimate sophistication.
Tools change. The craft remains.
We will continue to code.

Dino’s Design

The first line of Dino’s manifesto is the whole point: collaboration over automation. Everything else in this document follows from that one choice.

The Wrong Metric

Most coding agents — Claude Code, Codex, and the rest — optimize for a single metric: how long can the agent work autonomously without you? The longer the unattended run, the better the product is considered to be.

Dino thinks this is the wrong thing to optimize for. An agent that works for twenty minutes on its own is an agent that can drift for twenty minutes in the wrong direction — and you only find out at the end. The right metric is how effectively you and the AI work together: reading, reviewing, reasoning, and iterating toward a solution you actually understand and trust.

AI should augment the developer, not replace them.

The difference plays out in every part of the workflow:

Autonomous Coding Agents	Collaborative Coding Agent (Dino)
Optimizes for output volume	Optimizes for developer comprehension
Goes off and makes changes directly on disk	Stages changes in memory for your approval
Asynchronous — you review after the fact	Synchronous — you course-correct in real time
Permission dialog on every action, or accept-all (YOLO mode)	No permission dialogs; everything staged until you apply
Compacts — lossy summary when context fills up	Garbage-collects stale content, keeps the conversation

The rest of this document explains how Dino delivers on the right-hand column.

The Joy Is in the Struggle

Plenty of developers still genuinely enjoy coding. Dino is built on the premise that AI, used well, makes coding more fun — not less — because it lets you take on more ambitious projects and build better software. But only if you stay engaged: read the code, review every change, reason through the trade-offs, debug when it breaks.

The reward of programming is the struggle and the solution — the hard problem finally cracking open. Handing that off entirely is handing off the part worth doing. Dino is for people who want to keep coding, just with a much sharper tool. We will continue to code.

Stay in the Flow

Developers used to have a tight loop: make a change, see the change, iterate. AI coding agents broke it. You send a prompt, wait five minutes, send another, wait five more. That long, asynchronous round-trip pulls you out of the zone — so people either context-switch between several agents or give up and take themselves out of the loop entirely. Both workarounds have real costs.

Dino restores the synchronous loop by optimizing for speed. Batch operations collapse many tool calls into one — opening three files takes a single call instead of three, and three edits across files land in one call instead of three. That’s not a minor tweak. It’s the difference between a 30-second wait and a 90-second wait, which is the difference between staying in the flow and reaching for your phone. Because Dino is fast, you watch every tool call and edit as it happens — and if it opens the wrong file or starts down a bad path, you stop it immediately and redirect.

Safe by Design

Other agents force a bad choice: approve a permission dialog on every action (tedious), or accept everything at once — “YOLO mode” (risky). Dino refuses both extremes.

Nothing Dino proposes touches your files until you say so. Every edit lives in a virtual staging layer in memory — never on disk — until you explicitly apply it. You can review, iterate, and refine as many times as you want with zero risk. This is also what makes multiple Dino tabs safe: each tab holds its own isolated staging layer, like independent feature branches working on the same codebase without overwriting each other. There’s nothing to lose, because nothing was written.

The Iterative Loop

You don’t need to write a detailed spec up front. Describe what you want, and iterate from there.

The core loop is propose → review → feedback → revise. Dino proposes a changeset, you review the diff, leave inline comments where something’s off, revert the parts you don’t want, and send it all back as a single prompt. Dino reads your feedback and produces a revised changeset. Repeat until the change is exactly right, then apply.

Because the loop is tight and safe, you can be loose with your first prompt. A rough instruction and a few rounds of feedback usually beat a perfect spec.

Review Every Line

Every change is presented as a diff — additions, deletions, and modifications, file by file and line by line. You step through changes, comment on any of them, selectively revert the ones you don’t want, and only then apply. You are the final authority; nothing merges without your sign-off. That’s what we review every line means in practice. For the mechanics, see Diff Review.

Every Chat Is a Feature Branch

Dino borrows its mental model from git. Each conversation is a tree of prompts and responses, and each tab is a feature branch with its own changeset history. You can edit a past message to branch into a new direction, rewind to an earlier point, or fork into a fresh chat — and when you branch, all the file edits up to that point come along too, so the chat and the workspace stay self-consistent. If the base branch advances while you work, Dino detects the conflict and offers a rebase. The version-control vocabulary isn’t a metaphor; it’s how the system is actually built. See Chat & Branching.

Thinking Over Typing

Typing code was never the point of programming — thinking was. Understanding the problem, weighing the trade-offs, reasoning through the design. The keystrokes are just the trace that thinking leaves behind.

Dino does the typing. It takes on the mechanical drudgery — the boilerplate, the repetitive edits, the same change rippling across a dozen files — so you can spend your energy on the part that always mattered. That part stays with you: read what Dino wrote, review every change, reason about whether it’s right, and steer it when it isn’t. Dino doesn’t do your thinking, and it isn’t meant to.

This is also why Dino keeps you in the loop instead of working unseen. An agent that types an entire feature while you wait isn’t freeing you to think — it’s handing you code you never reasoned through, to rubber-stamp after the fact. Dino proposes, you think, you decide. Thinking over typing is a reminder that the value was never in the lines typed, but in the thinking behind them.

Any Model, Any Budget

If AI is to do genuine good — not just for a few, but for everyone — it has to be within reach: affordable, easy to use, and rich in choice.

Being truly model-agnostic — not partially, not in name only — was one of Dino’s biggest engineering focuses. Switch models in the middle of a conversation, even one stacked with dozens of tool calls. Jump between models that speak different API formats — OpenAI one turn, Anthropic the next. Use a reasoning model for a hard problem, then drop to a fast non-reasoning model for the cleanup. The conversation, the tool calls, the staged edits — all of it carries over. The model is a swappable part, not a commitment.

This freedom is also a design constraint that shapes a lot of Dino’s engineering. Precise multi-file diff editing is notoriously hard. In most other coding agents, only the most capable models can perform the edits reliably; weaker models struggle — wrong tool calls, wrong edits, or fall back to rewriting entire files. Dino put real work into making diff edits reliable on weaker, cheaper models too, because if reliable editing only worked on the most expensive frontier model, then only people who could afford that model could use Dino well. That would defeat the point.

The practical effect: pair Dino with a $20/month flat-rate coding plan and it covers several hours of active coding a day. Two rotated plans stretch that to near-unlimited daily usage for around $40/month — a fraction of what per-token API billing would cost for the same workload. The model does the typing, you do the thinking, and the price is within reach of anyone. See Providers & Models.

Garbage Collection, Not Compaction

When a conversation approaches the context limit, most agents compact: they summarize the whole history into a single message so you can continue a little longer. It works, but it’s badly lossy — after compaction the model effectively forgets most of what happened, and quality drops noticeably.

Dino does something closer to garbage collection. After each turn it drops file contents that are no longer needed and trims tool results that have already been processed, while preserving the actual conversation. The context stays lean without losing what matters. The result is that Dino can sustain hundreds of turns inside a 250k-token window while holding its quality. If you do eventually run out, just open a new tab and start fresh.

Simplicity Is the Ultimate Sophistication

Every feature has to justify its complexity, and many don’t. So Dino deliberately omits MCP, a CLI, AGENTS.md files, @-references, slash commands, and sub-agents. Dino’s built-in tools cover the core development workflow; you can point Dino at any markdown file for instructions; you can name files in plain text instead of learning special syntax; and a single conversation handles tasks directly without orchestration overhead.

This isn’t a limitation list — it’s a design discipline. Complexity that doesn’t earn its place gets cut. Simplicity is the ultimate sophistication.

The Craft Remains

Tools change. The craft of programming remains. Dino is built with care for the details that make a tool feel good to live in: smooth and fast, memory-efficient, a ~2MB install that outperforms tools many times its size, beautiful markdown with syntax highlighting, tables, and LaTeX, and themes and fonts chosen deliberately. The love is in the details.

Design at a Glance

Principle	What it means in Dino
Collaboration over automation	Optimize the joint loop, not unattended run-time
Thinking over typing	Dino does the typing; you stay in the loop to review, reason, and steer
Any model, any budget	Truly model-agnostic; precise edits on cheap models; cost within reach
Understanding over speed	But fast enough to keep you in the flow — batch ops, synchronous review
Safe by design	All edits in an in-memory staging layer until you apply
Review every line	Diff-first; you’re the final authority
Every chat is a feature branch	Branching, rewind, fork, rebase — on chat and files
Garbage collection over compaction	Lean context without lossy summaries
Simplicity is a feature	Complexity must justify itself; what’s absent is deliberate

For what these principles look like in practice, continue to Features or Getting Started.