Features

Dino is built for collaboration over automation. Instead of optimizing for how long the AI can work without you, Dino optimizes for how effectively you and AI can work together — reading code, reviewing changes, reasoning through problems, and iterating toward a solution.

Here’s what Dino can do.

Collaborative Chat

Dino’s primary interface is a chat tab inside VS Code. Describe what you want in natural language and Dino responds with explanations, code, and actionable changes.

Every interaction is a dialogue, not a one-shot transaction. Dino explains its reasoning, asks clarifying questions when a request is ambiguous, and presents all changes for your review before applying anything.

The typical way to work with Dino is iterative: send a prompt, review the result, leave feedback, and refine. You don’t need to write a detailed spec upfront — just describe what you want and iterate from there.

You can attach files and images to your messages by dragging them from the file explorer, pasting from clipboard, or using the attachment button. This is useful for sharing screenshots of errors or providing visual context. For files already in your workspace, just mention the file name or path — no special syntax needed — and Dino will read it directly.

How the Agentic Loop Works

When you send a prompt, Dino enters an agentic loop — it thinks, opens files, makes tool calls, thinks some more, and edits code. This whole sequence is triggered by a single prompt. You can expand thinking blocks and tool calls to see exactly what Dino is doing at each step.

A common misconception is that only reasoning/thinking models can do this reliably. In practice, even non-reasoning models make reliable tool calls thanks to modern post-training. Thinking is valuable for complex problems, but it’s not a requirement for tool calling or the agentic loop.

Synchronous Workflow

Most AI coding agents use an asynchronous workflow: you write a prompt, the agent goes off and works on its own for minutes or hours, and you review the result after it’s done.

Dino is synchronous. You see every tool call and edit as it happens. If Dino searches the wrong directory or starts editing the wrong file, you can stop it immediately and redirect. This works because Dino optimizes for speed — batch open, batch edit, and minimal round-trips mean you’re not waiting long after each prompt. The feedback loop is tight — you stay in the flow instead of waiting for a long async task to finish, only to discover it went in the wrong direction.

Safe by Design

Dino never modifies your files without your approval. All proposed changes live in a virtual staging layer in memory — not on disk — until you explicitly apply them.

Other coding agents often force you into one of two extremes: approve every permission dialog (tedious) or accept everything at once (“YOLO mode” — risky). Dino avoids both: changes live in a staging layer where you can review, iterate, and refine as many times as you want before applying anything to disk.

This also means multiple Dino tabs can work on the same codebase without overwriting each other. Each tab has its own isolated staging layer, like having independent feature branches.

Precise Multi-File Edits

Dino performs surgical edits across your codebase — not full file rewrites. When a refactor touches your model, controller, tests, and documentation, Dino proposes all changes as a single coherent changeset.

The edit system handles:

• Single edits — Replace a specific block of code in one file
• Batch edits — Apply multiple edits across several files in a single operation
• Find and replace — Replace every occurrence of a pattern in a file (with optional regex support)

Precise diff edits are more token-efficient than full-file rewrites. Other coding agents often require the most capable models to make precise edits work reliably — weaker models often make mistakes with precise diff edits or fall back to rewriting entire files, which is slow and wasteful. Dino’s edit tool is optimized to make precise diff edits work reliably across all major models, not just the most expensive ones.

Batch Operations for Speed

Dino is designed for a synchronous developer workflow — make a change, see the change, iterate. To keep turnaround fast, Dino uses batch operations:

• Batch open — Instead of making three separate tool calls to open three files, Dino opens them in one call. Three times as fast.
• Batch edit — Instead of making three separate edit calls for three changes, Dino applies them in one call. Again, three times as fast.

This isn’t a minor optimization — it’s the difference between waiting 30 seconds and waiting 90 seconds for a response, which is the difference between staying in the flow and context-switching away.

Diff Review

All proposed changes are presented in a GitHub-style diff viewer:

• File picker — Jump between changed files from the header menu
• Change navigation — Step through each individual change with j/k or arrow keys
• Inline comments — Click any change to leave feedback for Dino
• Selective reverts — Toggle individual changes for removal before applying
• Send Feedback — Send all comments and reverts back to Dino as a new prompt, so it can revise its changes based on your input

Apply & Commit

When you’re happy with the changes:

• Apply to Disk — Write all approved changes to your filesystem
• Apply & Commit — Write changes and create a git commit in one step. Dino can auto-generate a commit message based on the diff.

Version Control

Each Dino tab acts as a feature branch with its own changeset history:

• Changesets — Each round of edits creates a changeset. You can review and apply changesets independently.
• Commits — Apply a changeset to disk and optionally commit it to git, with a co-authored-by trailer.
• Rebase — If your base branch advances while you’re working (someone pushes new commits), Dino detects the conflict and offers a rebase to merge your changes onto the latest state.

Conversation Branching

Not every conversation goes in a straight line. Dino lets you branch and explore:

• Edit past messages — Modify a previous prompt and rerun from that point. Dino creates a new branch, preserving the original conversation path.
• Rerun — Regenerate Dino’s response to a prompt without editing the prompt itself.
• Rewind — Jump back to an earlier point in the conversation and continue from there.
• Branch navigation — Switch between alternate branches of the conversation, like navigating git branches.
• Branch into a new chat — Start a new chat from any point in the current conversation, with its own title.
• Fork — Duplicate a conversation at any point to explore a different direction.

When you branch or fork, all file edits up to that point come along too. Branching isn’t just for the chat — the staging layer state is copied as well, so everything stays self-consistent.

Branching is available on the Pro plan. Free users can still view their conversation history but cannot edit past messages or create branches.

Chat History

Every conversation is saved automatically. Access your history from the title bar:

• Search — Filter chats by title
• Open — Resume any past conversation right where you left off
• Rename — Give conversations meaningful titles for easy retrieval
• Delete — Remove conversations you no longer need
• Copy — Export a conversation as Markdown or JSON

Model Agnostic

Dino works with any LLM provider. Connect your own API keys and switch models freely:

• API Key Providers — OpenAI, Anthropic, Google, Mistral, DeepSeek, OpenRouter, and more
• Coding Plans — Flat-rate subscriptions from Synthetic, Fireworks AI, MiniMax, Moonshot, Z.ai, and others that offer generous usage for a fixed monthly price
• Local Models — Ollama, LM Studio, or any local server with OpenAI or Anthropic API format
• Custom Endpoints — Any endpoint with OpenAI or Anthropic API format

Switch models at any time — even mid-conversation. A practical strategy: start with a fast, affordable model for the initial pass. If it struggles, switch to a more powerful model to finish the job.

Context Window Management

Most coding agents rely on compaction — automatically summarizing the entire conversation when you approach the context limit. This is very lossy: after compaction, the model effectively forgets most of what happened, and you’ll notice a significant drop in quality.

Dino takes a different approach, closer to garbage collection: after each turn, it cleans up file contents that are no longer needed and trims tool results that have already been processed. This keeps the context lean without losing important information.

The result: Dino can sustain hundreds of turns within a 250k token context window, maintaining quality throughout. If you do eventually run out of context, simply open a new Dino tab and start a fresh conversation.

Rich Markdown & Math

Dino renders responses with full markdown support:

• Syntax-highlighted code blocks with language detection
• Tables for structured data
• LaTeX math — Inline ($x^2$) and block ($...$) equations
• Images — Rendered inline from image URLs
• Thinking blocks — When a model uses extended thinking, Dino shows the reasoning process with duration

Token-Aware

Dino tracks token usage in real time:

• Context window — See how much of the model’s context is being used
• Input/output tokens — Track cumulative token costs per conversation
• Cached tokens — Monitor cache hit rates to understand cost savings

What Dino Doesn’t Do

Dino is deliberately simple. It doesn’t support:

• MCP (Model Context Protocol) — Dino’s built-in tools (file search, code edit) cover the core development workflow. MCP adds complexity without proportional benefit for the way Dino works.
• CLI — Dino is designed for collaboration, not automation. A CLI optimizes for headless execution; Dino optimizes for the iterative loop where you review every change. If you need a CLI, tools like Claude Code already serve that well.
• AGENTS.md / Skills — These are just markdown files that tell the AI how to behave. You can point Dino to any markdown file in your project and it will read and follow the instructions. No special format needed.
• @file references / Slash commands — No special syntax required. Just mention file names or paths in plain text and Dino will find them. Slash commands may be added later, but for now the chat interface is deliberately simple.
• Sub-agents — Dino handles tasks directly in a single conversation. Delegating to sub-agents adds orchestration complexity without clear benefit for the collaborative workflow.

This isn’t a limitation list — it’s a design choice. Every feature Dino includes has to justify its complexity. So far, these haven’t.