SSFS is a developer workspace for spec-driven development with your coding agents. Start with a ready-made workflow to clarify requirements, plan implementation, and check the result. Adapt the process as you work.
A retried payment request must never charge the customer twice.
Agent
The biggest cost is not writing code but checking code that missed the intent. SSFS moves the effort to the start: agree on the requirements, then verify against them.
The volume of changes happening per unit of time is so huge that I don’t understand how a human can track it at all.
The agent reviews the code itself and highlights only the important files that need a human look. It takes responsibility for its own review, and you focus on what matters most.
The AI doesn’t always understand what the business needs, and sometimes bases its assumptions on how the code is already written.
Clarify behavior and edge cases with the agent before it starts writing code.
It’s still unclear which of this really speeds up work, which is worth doing, and which just creates more work to check.
Start with a ready-made preset. There is nothing to assemble, and everything stays adjustable when you want it.
Out of this whole wall of text, what really matters, and what did the AI just throw in for no reason?
Review focused requirements, a concrete plan, and findings in the context of one task. Decisions do not disappear: SSFS can see all your documents, so you can always ask what and why was decided.
If something isn’t written down, if something gets lost, the brain can simply forget. And you have to figure it out again and spend time on it.
In other agents you have to either hand context over from chat to chat explicitly, or switch off the search through chat history. SSFS passes only the context that is needed on to the next step by itself.
Everything you need to move from a task to a checked result. Nothing to assemble, but everything adjustable when you want it.
Start with a preset that already brings its documents, templates, and rules. Choose a process for features, fixes, or changes, including OpenSpec and GitHub Spec Kit, without installing or wiring up anything.
The agent explores the task with you and asks what is missing before it plans or writes code. Answers go straight into the document.
A short spec, a plan, and focused agent tasks — written for people, not for machines. Each with version history, authorship, and its own conversation. Read what matters, skip the rest.
Edit the documents, templates, and rules of a preset, and choose which agent runs each stage. Skip steps a small change does not need.
Run review and tests as separate steps, read the reports, choose which findings to fix, and mark the task done yourself.
A preset defines the documents: OpenSpec, GitHub Spec Kit, or your own. The size of the work determines how many steps to complete or skip.
Describe the software change, attach materials, and connect the local repositories.
Agent
Work through your next feature in SSFS.
SSFS does not replace your agent. It gives your agent requirements to build from and a process to follow.
Connected through ACP. Sign in with its own CLI and SSFS picks it up.
Connected through its own integration, with your existing Codex setup.
Connected through ACP, with your existing OpenCode setup.
All ACP agents are supported.
Large reviews usually follow unclear requirements, so clarifying them first removes much of the work. The agent then reviews the code itself against the specification and highlights only the files that need your attention, so you start from the issues instead of reading every file.
You write a short prompt, and the agent asks clarifying questions based on your codebase. The answers go into a specification that you can edit, so the agent builds from agreed requirements instead of a guess.
No. The agent asks only about what matters and does not bother you with small things. You stay in control: SSFS limits the agent to your project’s files, you configure the rules for running commands, and if you want, you can set it to ask about even the small things.
Yes. Start from the behavior you want, not from the technology. You read a plain-language specification and technical plan before any code is written, and you judge the result with review and test reports.
Locally. Your projects stay on your computer, and in one task you can work with several repositories at once. If you use a local agent, everything stays on your machine. If you use an agent such as Codex or Claude Code, the information is sent to its servers.
SSFS is free for the first two weeks, so there is no barrier to getting started. SSFS is in early access and pricing is not announced yet. We discuss terms personally with early users. The coding agent you connect is billed by its provider under your own subscription.
SSFS runs on your machine next to your repositories, with a local backend. In early access we walk you through the setup. You need a coding agent installed and signed in, and the project’s own tools to build and test the code.