Dev, your assistant in sessions

Dev is the AI assistant in every DevSpec session. It reads your code, searches what your project has already decided and done, and gives you its own honest view, so a conversation about a change starts from the facts rather than from memory. When the conversation settles something, Dev offers to record it as a task, a memory or a document. Dev plans and records; your agents write the code.

Who Dev is

Dev (shown as "DevSpec Assistant") is one assistant, the same in every project. There are no personas to choose between, and you can't pick which AI model runs it: DevSpec chooses that for you. What you can change is how hard Dev thinks, and how it talks to you.

Dev works like a sharp tech lead. It gives you independent judgement rather than agreement: it says plainly when something is wrong, names the trade-off when two people disagree, and changes its mind only when an argument or evidence moves it. In a session with several people it acts as a neutral facilitator, draws out quieter voices, and when the group decides, it records the dissent as well as the conclusion. It refers to things by their titles, and in its replies the tasks, documents and memories it names are clickable.

Dev is in sessions only. It doesn't take part in Messages (your one-to-one conversations). For questions about using DevSpec when you're not in a session, use Ask DevSpec in the ? menu, which is free. See Getting help.

Ask Dev something

You can ask Dev in a session in several ways:

• Pick Dev in the Send to picker beside the send button, then send. Your choice is remembered for that session.
• Or type @Dev in a message. That calls Dev even when you're posting to the room.
• Or open a message's menu and choose Ask AI to ask Dev about that message.
• Or use Ask privately (on Dev's row in the session's Agents tab) for a side conversation with Dev that stays out of the shared room.

Anyone who can post in a session can call Dev, including Viewers in a Shared session. Dev answers each person using that person's own Effort and reply style. See Sessions.

To stop Dev mid-reply, press the stop button that takes the place of the send button while Dev is working (Stop AI). A reply you stop isn't charged. If a reply is cut off by a connection problem, it shows "Response was interrupted before completing. Previous progress is preserved." with Continue; if something went wrong, it shows Retry. Either picks up from where Dev got to.

What Dev knows when a conversation starts

Each time Dev replies, it has the conversation, relevant project context and the basics: the project's name, vision and current goals, its repositories and branches, which database, logs and deployments are connected, your team's rules, who is in the room and their roles, and what's open in the room, such as polls, plans and points still to discuss. It also knows your name and the date and time where you are.

Dev searches your tasks, artifacts, memories and code when it needs more context, including when the conversation turns to something new. That way it can tell you when something was already built, is in progress, or was decided months ago, instead of letting the team re-debate it.

If you want Dev to consider a particular past conversation, paste the session's link or ask it to find the session where something was discussed.

What Dev can do

What Dev can reach depends on what the project has connected.

• Your code, when the project has a repository: search the code index, read the relevant lines of a file, list files, trace what depends on what, read git history and compare branches. With no repository, Dev has no code tools. See Code indexing.
• Your project's record: find and read tasks, briefs, memories, uploaded documents and artifacts; create and update tasks and briefs; write decision records, guides, plans and runbooks; record memories and replace out-of-date ones; manage goals; explain the Review queue and record your decisions; read a pull request with the work it delivered; see which database migrations are applied.
• Past sessions: search what was said in earlier conversations, and load a whole past session when you point it at one.
• The room: open a poll, run a shared plan the room can follow, ask one named person a question they answer in a card above the message box, and @mention people, who are notified.
• Files you attach: images and PDFs, and the text of Word documents. See Sessions.
• The web: search the web and read a page, for library docs, error messages and anything current.
• DevSpec itself: answer questions about how DevSpec works, from these docs, with links.
• Research helpers: for questions that need a lot of reading, Dev can send read-only helpers to research several parts in parallel.
• Your database, only when a Supabase database is connected: its tables, columns, relationships, indexes, row-level security, and Supabase's security and performance advisors. See Database and migrations.
• Your logs, only when Axiom is connected: search the datasets you've allowed. See Logs.

What Dev won't do

Dev never changes your repository. It doesn't edit code, commit, push, run commands, run builds or tests, or open pull requests. When a change is needed, it explains exactly what to change and where.

Dev also doesn't start an agent or hand work to one. When you say "get an agent on this", Dev makes sure the task is clear enough to work from, then points you to a way to hand it over: the item's Agent command, or an agent in the room that you instruct yourself. See Working with your agents.

A few other limits:

• Dev can't read code in a project with no repository.
• Dev doesn't see your deploys. It points you to the Delivery page. See Delivery.
• Dev changes Still to Discuss when you ask it to. DevSpec also keeps the list up to date as you talk.
• Dev can't see your Scratchpad; those notes are private to you. See Project Overview.
• Dev records your sign-off only when you ask it to. It can also check acceptance criteria with its tools and record evidence; sufficient evidence can complete eligible work automatically. See How an item reaches Done.

How Dev records what you decide

Dev writes to your project's record (tasks, memories, artifacts, goals, polls) during the conversation, never afterwards. Before it writes, it tells you what it plans to record and waits for a yes, unless you asked for it outright ("create a task for the login bug", "record that as a decision").

Tasks get a stricter rule. While you're still working out what to build, Dev collects the requirements as you talk and doesn't create anything. It creates the items when you say so ("create them", "that's the list", "go ahead"). Two or more related items go under a brief, and each item gets an intent, a description and acceptance criteria, so an agent can work from it without the conversation.

Before creating something, Dev looks for existing items and records that already cover the same work, or that the new one would undo, and asks whether to update the existing one, replace it, link them or keep both. If you've already dealt with the overlap, it doesn't raise it again.

What Dev writes is checked against the role of the person who asked:

• A Viewer's request can't change the record. Dev tells you it can't.
• A Reviewed Contributor's work and knowledge are proposed for a Maintainer to accept.
• A Contributor can add work and knowledge. Changes to agreed work need approval; changes to knowledge depend on whose decision they affect.
• A Maintainer can manage the project and accept proposals. Undoing another Maintainer's decision needs its owner's OK or the project lead's.

Dev always reports what actually happened: written, proposed or refused. See Organizations, members and roles and Review.

Make decisions in the conversation

Ask Dev what is waiting for you in Review. It can explain the records involved and record your decision when you tell it what you want: accept or decline a proposal, answer a conflict, confirm that a record is still accurate, or resolve a duplicate.

When your answer is clear and you can make that decision, Dev acts on it. You do not need to repeat it on another page. If somebody else needs to agree, Dev asks them to confirm their own answer; the record stays unchanged until they do.

Talk it through on a Review question opens a session with the question and its relevant records. Dev helps you understand the disagreement and explore alternatives, then records the answer you give. See Review.

Choose how hard Dev thinks: Effort

Effort sets how deeply Dev reasons before it replies. To change it, open Send to, pick Dev, then choose Dev settings and Effort.

Effort is your own setting, not the session's. It applies to every message you send to Dev, in every session, until you change it, and teammates asking Dev in the same room get their own setting. Higher effort takes longer and costs more per reply, because Dev does more work. If a level isn't listed, it isn't available at the moment.

Look something up on the web

Dev can search the web and read pages when a question needs current information from outside your project, such as a library's documentation, an error message or a release note. It decides for itself when a search would help, and you can also ask it to look something up or paste a link for it to read.

Each search and each page Dev reads is charged to your organization's balance. See Billing, usage and limits.

Change how Dev replies to you

How Dev talks to you is your own preference, set in Settings → Replies & voice → Response style:

• Conversational replies asks for short, direct answers that read like someone talking, not a written report. When you raise several things at once, Dev shows it heard all of them, takes them one at a time and comes back to the rest on its own; ask for everything and you get everything. With it off, which is how it starts, Dev matches the length of each answer to the question.
• Focus on the product, not the code asks Dev to explain things in terms of what people can do and the choices you need to make, and to skip code-level detail unless you ask. It's off until you turn it on.
• "Anything else about how you want to be answered?" is a free-text box of up to 10,000 characters, for things like "Assume I'm a senior engineer" or "Give me the trade-off before the recommendation."

You're offered both switches when you first set up your profile, and both are also in the composer's settings (the gear beside the message box).

Your response style follows your messages to Dev and to your own connected agents. It only shapes the reply you read: it never shortens what gets written into a task, a brief or a document. See Your settings.

Long conversations

A session can run as long as you need. As a conversation grows, Dev condenses the oldest part of its history into a summary so it can keep going. A line reading Earlier context summarized marks where that happened. The full transcript is still there for everyone to read; only Dev's working memory is condensed.

If a session gets so long that Dev can't take another message, or its answers start losing track of early details, start a new session. You can bring part of the old conversation with you: choose Select messages from a message's menu, pick the messages, and start another session with them. Dev can also search the old session whenever you ask.

What Dev costs

Dev's replies are charged to your organization's balance, in dollars, for the work each reply takes. That includes the research helpers Dev sends out, condensing a long history, web searches and pages read, and Ask privately. Posting to the room without calling Dev is free, and so is a reply you stop.

Dev's usage counts toward your personal allowance, which Dev, reading aloud and voice input share, if your Owners and Admins have set one in Settings → Usage & limits. Before each reply DevSpec checks there's room. If there isn't, Dev doesn't reply and the message says what stopped it: Dev switched off for you, your personal allowance, the project's limit, the project being paused by an Owner or Admin, or an empty balance, and who can change it. A reply that starts is charged in full, even if it takes your allowance, the project's limit or the balance past its end; the next reply is the one that waits. See Billing, usage and limits.