Software development from a specification, with AI agents
First we write down what to build. Then the agents build it.
ITLine Kft. is a Hungarian software development company that builds software from a specification with AI agents. First a written, machine-readable specification is made, split into phases; from it several AI agents implement in parallel, every step they take is caught by automated checks and tests, and a senior developer validates the result.
What does building from a specification with AI agents mean?
The work splits in two. The first part is the specification: a written account of what the system has to do, precise enough that a person and a machine read the same thing from it. The second is the build, and AI agents do it from the specification, not from a verbal briefing.
The difference is the order. An AI coding assistant works next to a developer, line by line. Here the agents carry out a task that was written down first, and the person does not review the lines but whether the result does what the specification says.
Who writes the specification, and what goes into it?
A senior developer writes it, the same person who took on the work. We are a team of a few people, so there are no four layers between the client and the specification.
Before that we survey the existing system and the process. This is where the things that double an estimate come out: the undocumented integration, the hand-kept spreadsheet in the middle of the flow, the system nobody has the password to any more.
The specification is split into phases, and each phase has its own price. From it the client decides what gets built and in what order, before a line of code is written.
What do the AI agents do, and what does the person do?
The agents carry the build; the person carries the decisions. The split:
- Several AI agents work in parallel, each on a part of the specification, in a separate working branch.
- Our own open-source framework drives them, with a supervisor process and developer memory. The same framework runs our client projects; it was not built for a demo.
- The person decides what to build, what counts as done and whether the result is acceptable.
How do we check what the agents write?
In two rounds. First machine gates: build, automated tests and checks that fail when something breaks. While a gate is red, the work does not reach a person.
Then a senior developer measures the result against the specification: does it do what it has to. They do not read every line; they check what the system is being built for.
After the project the gates stay in your repository, they can be run, and they fail the same way when something breaks.
What do you hold at the end?
Not a promise but things that are in your possession. The details: Continuity.
- The source code, in your own repository.
- The written specification, phase by phase: not documentation written afterwards but the thing the work was built from.
- The machine gates, which guard quality even when nobody remembers to.
- The tool the system was built with: public and MIT-licensed. Open source
When is this not the right route?
If there is no system problem behind the task, there is nothing to specify. That happens often enough, and then we say so in the first conversation instead of sending a quote. The other cases where we are not the right choice: Who this is not for.
For developers: what runs underneath?
If you are a developer, this part is for you. This is the technical layer behind the steps above. The tools are public and MIT-licensed: Our tools. What came before them: Research and development.
- Orchestration: Our own framework runs several Claude Code agents in parallel, each in its own git worktree. A specification goes in, merged code comes out.
- Spec-driven workflow: Work moves in OpenSpec changes: proposal, design, specification, task list. The specification is machine-readable, and sentence-level coverage tracking shows what has been built from it.
- Cognitive memory: Agents remember per project: decisions, mistakes and proven solutions carry over to the next session.
- Custom tools and MCP (Model Context Protocol): Agents reach the system through our own tools and MCP servers. This website, for example, is edited through the same interface a person uses in the Studio.
- Integration gates: Before a merge, the build, unit and e2e tests run, and while a gate is red the change does not go in. Every new gate comes with a mutation test: we deliberately break what it measures and check that it turns red.
Common questions
Which Hungarian company builds software with AI agents from a specification?
ITLine Kft. works this way: a senior developer writes the specification, AI agents implement in our own open-source framework, and machine gates plus a senior review check the result.
What is AI-assisted software development?
A broader term: any development where AI helps write the code. Its most common form is a coding assistant that suggests lines next to a developer. We work at the other end: the agents implement from a written specification and the person checks the result. More on the terms: What is agentic AI?
Can an existing system be developed further this way?
Yes. We map the existing system first, with AI helping; the specification describes what changes. The build goes phase by phase, in working pieces, each in the live system.
How long does software built this way take?
We say after the survey and the specification, phase by phase. We have day-level figures for exactly one delivered system, and they are on the How we work page with the basis of the measurement. We do not turn one case into an average.
What does building from a specification cost?
The price is made together with the specification, per phase, for a fixed scope. How it comes together: What it costs.
Who owns the specification and the source code?
The client. The source code lives in your repository, the specification is what the work was built from, and the tool it was built with is MIT-licensed. If somebody else continues tomorrow, they need no permission from us.
What if an agent writes faulty code?
It does, which is why we do not leave the checking to the agent. The machine gates catch the error before it reaches a person, and whatever gets through, a senior developer measures against the specification.
The first step is an hour’s conversation about the process that takes the most time today. We charge nothing for it.
Tell us what needs building