sdd-spec-kit

Candidate: Tony Miasoedov, Senior Software Engineer
Company: https://github.com/Beefeater84/sdd-spec-kit
Period: 2025 — present
Role: Founder, solo developer
Team: Solo project
Main result: Built an open source AI feature factory that orchestrates agents from task to PR, with hooks as safeguards and a human reviewing only the plan and the final PR; it runs real projects with real users and is used by at least 6 more developers.

Context

An open source project to build an agent factory that adapts to my workflow and minimizes the tokens spent on tasks, the number of errors, and manual prompting for repetitive tasks.

What I did well

This agent factory runs real projects — yki-testi.fi and www.groci.fi — with real users and real tasks.
The project is an orchestration of agents, from picking up a feature all the way to a PR.
Most stages are deterministic, which reduces the chance of errors and the need for manual intervention. They are moved into separate agents on weaker models and return a standardized result to the orchestrator.
There are safeguard mechanisms that forbid direct PRs and creating branches from master, because a push to master triggers the CI/CD production build. This is enforced with hooks, since any prompts are only recommendations.
There is a starter agent that updates the master and development branches before work begins, so I always work with the latest version of the code. Since development happens in a cloud environment, from my phone, and from my computer, this avoids conflicts and keeps me working with the latest changes.
The orchestrator is connected to project management systems: GitHub Projects, Linear, Jira. It knows which project it belongs to, can browse tasks on its own, update their status, and create new tasks as needed.
There is an agent that checks whether a task is standalone or part of an epic. While an epic is in progress, the requirements, the implementation, and the inputs / outputs can change, but the task doesn't get updated. So a dedicated agent checks this, and if the task is part of an epic, it checks whether the task is still accurate and updates it if needed.
There is an organized feedback loop: the developer agent and the validator agent check each other independently and give feedback, which improves code quality and reduces the chance of errors.
A human takes part in 2 stages. First, they get a solution plan written for a human — without unnecessary technical details — so they can easily understand what needs to be done and check the approach and the logical correctness of the task.
The final PR is also left for human review, because the CI/CD build provides a preview link with real data, and we can open it from a phone and see how the changes will look in production before they are merged even into development. You can make edits, roll back to any decision, or change any decision, and the agent will roll back those changes, record them in the feature's comments, and won't go down the same path in future work.
There is a separate releaser agent that oversees the release of new versions: it runs the full test cycle — unit, integration, and e2e tests — and checks that the build and deploy to staging are correct before releasing to production. It publishes a new tag and creates a release in the version control system.

Results

The orchestrator has significantly reduced the number of errors and manual intervention in the development process.
I shared it in a private club of AI developers (podlodka.ai), and I know of at least 6 more people who have started using it in their projects.
I'm currently building a new module that automatically creates an index of modules in the code, making it easier to navigate the code structure and find the right modules in medium and large projects.

Stack & skills

Feature factory: Built an open source agent factory that takes a feature from the task all the way to a PR, tuned to my own workflow.
Agent orchestration: An orchestrator runs separate agents for each stage — starter, epic checker, developer, validator, releaser — and gets a standardized result back from each.
AI native: The factory runs real projects with real users — yki-testi.fi and groci.fi.
AI first: Development happens from a cloud environment, a phone and a computer; a human only reviews the plan and the final PR.
AI agents: Built a developer and a validator agent that check each other independently and give feedback.
Spec-driven development: A human gets a solution plan written for a human, without unnecessary technical details, to check the approach and logic before coding.
Cost optimization: Moved deterministic stages into agents on weaker models to minimize the tokens spent on tasks.
Git: Forbade direct PRs and branches from master with hooks, since prompts are only recommendations and a push to master triggers the production build.
CI/CD: Every PR gets a preview link with real data from the CI/CD build, so changes can be checked from a phone before merging even into development.
End-to-end testing: A releaser agent runs the full test cycle — unit, integration and e2e — and checks the staging deploy before every release.
API integrations: Connected the orchestrator to GitHub Projects, Linear and Jira, so it browses tasks, updates their status and creates new ones.
Automation: Automated repetitive tasks to minimize errors and manual prompting.
Communication: Shared the factory in a private club of AI developers; at least 6 more people use it in their projects.

Full CV index — Tony Miasoedov