Frequently Asked Questions

The flat rate is our main offer: all the software you need for $4,500 a month. Our senior developers handle everything, from scoping and decisions to building, review, and follow-ups, with our AI system doing the production work. One of them is your personal point of contact. Finished pull requests land in your repository, one task at a time. Cancel anytime, with a 14-day money-back guarantee on the first month that runs until you approve the first pull request.

Choose the flat rate when you want software built without doing any of it yourself: our senior developers make the technical decisions, run the delivery, and stay responsible for the result, with one of them as your personal point of contact. Companies replacing an agency, a freelancer, or a planned hire are the typical fit.

Anything software: features, bug fixes, integrations, performance problems, new apps, rough ideas, half-written specs, the bug report a customer just emailed you. It does not need to be a clean ticket. If it's software, it's included. What we don't do is fill seats on your team or take on hardware and deep embedded systems.

That's most of our clients. Decisions in someone's head, requirements in a Slack thread, a product full of unwritten rules. Send it in whatever form it exists. We read the code, ask the few questions that matter, and remember the answers, so every task needs less explanation than the one before. When a call genuinely helps, we do a call.

I'm Vincent Schmalbach, a senior full-stack engineer with 15+ years of experience, and I built Vroni. My team and I run every engagement: the system produces, senior engineers architect, steer, and review. Nothing reaches your repository without senior review.

Your first month is covered for 14 days: if you want out, you get your money back, no questions asked. The guarantee runs until you approve the first pull request we deliver, and from then on the normal deal applies: month to month, cancel anytime.

Focus. You always have something in flight, and we pull the next task the moment one ships. There is no task counter and no meter; big months and quiet months cost the same.

The price covers one product, which is typically one repository. Each extra repository is real overhead on our side, so if you run more than one product, we price that in the first conversation. It is often much less than a second plan, because we still work one task at a time. The reverse is possible too: if you want more than one task in flight, we can do that at a higher price. For the typical client, the price on this page is simply the price.

Then it gets built anyway. You're not buying AI; you're buying shipped software. When the AI isn't enough, senior engineers do it the old way, at the same price. You bought the outcome, not the method.

Because the expensive part of development is not the typing anymore. Our AI system does the production work, and our senior engineers spend their time where judgment matters: scoping, architecture, decisions, and review. Agency prices also pay for meetings, project managers, and juniors learning on your budget; ours doesn't. Google's engineers describe the same division of labor in their New SDLC whitepaper.

No. Send us what you have by email or GitHub issue, whichever you already use. There's a dashboard if you want to watch progress, but it's optional. The only requirement is a GitHub repository to deliver into, and we can set one up for new projects.

You do. Everything is delivered into your repository as pull requests and is yours from the first commit. Access is scoped to the repositories you choose and revocable at any time.

The popular web stacks: PHP/Laravel, TypeScript/JavaScript, React, Vue, Node.js, Python, Go, plus databases, queues, APIs, third-party integrations, and AI features on OpenAI, Anthropic, and Google APIs. If your stack is unusual, just ask.

It depends on the task, and we won't invent a number. Small, well-bounded tasks often come back fast; bigger pieces get broken down and delivered as a sequence of pull requests. You'll always know what's in flight and what's next.

The flat rate is full service: our senior developers handle everything, and one of them is your personal point of contact. Self-serve is just the AI, without a human in the loop: you connect your GitHub repository, assign tasks yourself, review the pull requests yourself, and pay per active minute. Self-serve plans start at $299 a month.

No. The flat rate is managed delivery at one published price. Custom or enterprise needs such as procurement, invoicing, security review, or larger rollout planning can be scoped on top of it.

Send us your first task through the form. We reply with any questions, sort out repository access, and get building. Slots are limited and onboarding is personal, so if we're at capacity we'll tell you and hold your place.

Vroni is a software delegate: an autonomous AI developer you assign tasks to. Give it a task, issue, bug report, product idea, or spec. It reads the codebase, plans the task, writes code, runs checks, fixes failures, and returns a pull request.

Claude Code, Codex CLI, and similar tools are AI coding agents. They are powerful, but they are usually meant to be used interactively by a developer who plans the task, drives the tool, reviews the output, fixes problems, and keeps the task moving. Vroni replaces the developer in that workflow, not the coding agent. You assign the task and Vroni runs the process. Under the hood, Vroni uses state-of-the-art AI coding agents, including tools like Claude Code and Codex CLI, inside a larger engineering workflow for planning, implementation, checks, failure repair, and follow-up requests. You get the benefit of those coding agents plus a system built to deliver finished software.

Vroni is for anyone who needs software built, fixed, or improved: solo founders, small businesses without developers, agencies, product teams, and engineering teams with more tasks than time.

No. Developers can give Vroni precise technical tasks, but non-developers can also describe the outcome they want in plain language. More detail helps, but a short brief is enough to start.

Vroni can be the only developer for a small product, or an extra senior developer for an existing team. It does real implementation, but you still decide what task to assign and when a result should be merged or shipped.

No. Vroni is built for serious development tasks. It can start from rough input, but the goal is production-quality implementation, not throwaway prototypes.

Vroni can handle features, bug fixes, UI updates, API endpoints, tests, refactors, documentation, integrations, performance fixes, and architecture updates. It is not limited to small tickets.

No. A clear ticket is useful, but Vroni can also start from a rough idea, a bug report, a support note, a product brief, or a follow-up comment. If you give details, Vroni follows them. If you give less detail, it plans from the context it has.

A software delegate is an autonomous AI system that accepts high-level software tasks, executes them asynchronously using development tools and runtime environments, and returns reviewable software artifacts such as pull requests, apps, tests, fixes, or deployments.

Because the main action is delegation. You are not prompting a coding tool step by step. You assign the task, Vroni carries it forward inside clear boundaries, and you get software back.

Delegated software engineering means handing a software outcome to an autonomous system that can plan, implement, check, repair, and return the result. The user provides intent and boundaries; the delegate does the engineering.

A coding agent is usually a tool a developer operates directly. A software delegate is the larger workflow around the task: intake, planning, coding, checks, repair, summaries, artifacts, permissions, and handoff.

A copilot helps while you code. A software delegate takes assigned tasks and keeps going without you steering every step. The difference is not only intelligence; it is the ownership of the workflow until a result is ready.

A chatbot answers in conversation. A software delegate uses development tools, edits real code, runs checks when possible, and returns software artifacts. The output is not just advice; it is software you can inspect and ship.

No. Running in the cloud helps because tasks can run asynchronously, but the category is broader than hosting. A software delegate has a bounded workflow for accepting tasks, executing them, checking them, and returning artifacts.

Bounded autonomy means Vroni can act independently inside a defined task, repository, runtime, permission set, and review process. It is autonomous enough to complete the task, but not unbounded across your whole business.

Depending on the workflow, a software delegate can return pull requests, updated apps, tests, bug fixes, documentation updates, summaries, verification notes, and deployment workflows.

You still describe the task, but you do not need to drive the implementation step by step. A short task can be enough. A detailed spec is still useful when you have one.

It can be, depending on the task. For a small business or solo founder, Vroni can act as the main developer for many tasks. For an existing team, it can take tasks that would otherwise wait for developer time.

The flat rate is available now: send us your first task through the form and we get started. Self-serve access (Solo and Team) is opening in batches; join the waitlist and we will contact you before paid access opens.

You leave your details and the kind of task you want Vroni to handle. We will use that to prioritize access and contact you when your workspace can be enabled.

On the flat rate, send the task in whatever form it exists, by email or GitHub issue, and we take it from there. Self-serve is GitHub-based: connect the GitHub App, assign or label an issue for Vroni, and wait for the pull request.

Start with a real but contained task: a bug fix, a UI cleanup, a small feature, a test gap, a refactor with clear boundaries, or a product update you already understand. After that, give it larger tasks.

No. A full spec helps when you have one, but it is not required. Vroni can start from a few sentences, inspect the repository, form a plan, and produce a sensible result.

Include the desired outcome, relevant links, screenshots, error messages, acceptance criteria if you have them, and anything Vroni should avoid changing. The more context you provide, the less guessing is needed.

Yes. Vroni can start from rough input. For very ambiguous product requests, the flat rate is a better fit: we clarify the brief with you, turn it into something buildable, and handle the delivery end to end.

The first release is centered on GitHub because it gives Vroni a clear way to receive issues and return pull requests. Vroni is not conceptually limited to GitHub, but GitHub is the initial workflow.

Vroni reads the task and repository, plans the task, edits the code, runs available checks, investigates failures, fixes what it can, and prepares the result with a clear summary.

Vroni returns a pull request with the implementation, a summary of what Vroni did, and the checks or verification steps it ran.

Yes, the first workflow returns pull requests in GitHub. That keeps the result visible in the workflow developers already know.

You can review the pull request like any other code update, but Vroni is built to return results that are ready to merge in normal cases. How much review you do is up to your team and risk level.

You or your team merge it. Vroni prepares the implementation and keeps the context visible; your normal repository permissions decide who can merge.

Yes. Leave feedback on the issue or pull request and Vroni can continue from there with a follow-up run.

Yes. Follow-up comments are a natural part of the workflow. Vroni can update the same pull request instead of making you start a new task from scratch.

Vroni reports the useful reason in plain language. If the task needs user action, you can add more context. If it is a product or platform issue, support has the diagnostic detail needed to investigate.

Yes. Vroni runs in the cloud. You can assign a task, move on, and come back later to the pull request and run history.

It depends on repository size, task complexity, available checks, and how many repair loops are needed. Vroni optimizes for quality over raw speed, so difficult tasks can take longer than a quick coding-agent pass.

Vroni is meant to replace real developer time, not only generate code quickly. Better planning, stronger models, multiple checks, and repair loops cost more time and compute, but they produce better software.

Vroni is fast compared with waiting for developer availability, but it is not optimized to be the cheapest instant code generator. It spends time understanding, implementing, checking, and fixing.

Vroni uses strong coding agents and models under the hood, but it does not simply pass your task to one tool once. It runs them through Vroni's own workflow for planning, implementation, review, and QA.

It is the practice behind the flat rate: clear rules for what the AI does and what senior engineers do. The AI produces; seniors set intent and architecture, make the decisions, verify correctness, and own the result. Google's engineers describe the same division of labor in their New SDLC whitepaper, and our page The New SDLC has our take on it.

Vroni runs relevant checks when they are available and practical for the task. Good project test commands, build commands, and lint commands help Vroni verify the result.

Vroni can still run, but confidence is lower. It will rely more on code inspection and task-specific verification. Adding tests or clear check commands improves results.

Yes. Vroni can handle architecture updates when the goal and constraints are clear enough. Larger architecture updates may be better split into a sequence of runs, or sent to us on the flat rate.

Yes. Vroni can refactor code, clean up duplication, improve structure, add tests around risky edits, and keep behavior stable when the intent is clear.

Vroni reads the repository and tries to follow existing patterns, naming, architecture, and conventions. Clear project notes and consistent code make this easier.

Vroni needs access to the repositories where it should implement tasks and open pull requests. You control that access through the GitHub App installation.

Yes. Self-serve plans include unlimited repositories. You pay for active Vroni time, not per repository.

Self-serve plans have none: unlimited repositories on Solo and Team, because you pay for active Vroni time, not per repository. The flat rate covers one product, which is typically one repository.

No special framework is required, but Vroni gets better results when your repository has clear install, build, test, and lint commands. Team includes tailored setup for your repositories.

Tailored setup means configuring Vroni around your repository: commands, conventions, review expectations, project notes, and known workflow rules.

Vroni uses repository context, prior task history, project conventions, feedback, and configuration notes to produce better future runs for the same codebase.

Yes, if the relevant project boundaries and commands are clear. Monorepos often benefit from tailored setup because the right package, app, or test command may not be obvious.

Yes. Vroni is designed for real private repositories. Repository access is controlled through the connected GitHub App.

One credit equals one active Vroni minute. Plans include monthly Vroni time: Solo includes 2 hours and Team includes 10 hours. Credits are used only while Vroni is active on the task: reading context, planning, editing code, running checks, fixing failures, or improving the result. Queue time, idle time, and time waiting for your response do not use credits. Do not compare two Vroni hours to two hours of human typing. A Vroni run includes planning, implementation, QA, failure repair, and follow-up handling, so two active Vroni hours can cover work that would otherwise take a developer several days. If you need more time after signup, you can buy top-up packs in-app whenever you need more credits.

Because Vroni time includes more than typing code. It includes understanding the request, planning the implementation, using state-of-the-art AI coding agents, running checks, repairing failures, and returning software you can inspect or ship. A human developer also needs availability, meetings, handoff, context switching, and often a day-rate commitment. Vroni turns that into autonomous execution time. For many tasks, one Vroni hour can replace far more than one human hour; the exact saving depends on the task and repository.

No. Pull request size varies too much. Vroni is billed by active Vroni time, because that better matches the actual effort spent.

No. Queue time, idle time, and time waiting for your response do not use credits. Credits are consumed only while Vroni is active.

You can buy top-up hours. Tasks use included monthly Vroni time first, then top-ups.

Top-ups are available as 2 hour, 10 hour, and 30 hour packs. After signup, you can buy them inside the app whenever you need more credits. They are useful when a sprint or launch push needs more Vroni time than your monthly plan includes.

Monthly included hours are plan capacity for that billing period. Top-up handling can be shown separately in billing before launch.

No. Vroni is a paid product. Joining the self-serve waitlist is free because you are not buying access yet, and the flat rate's first month carries a 14-day money-back guarantee that runs until you approve the first pull request.

Choose Solo for one user. Choose Team for shared access, priority queueing, unlimited seats, and tailored setup. Both include unlimited repositories. Choose the flat rate when you want our senior developers to handle everything for you. You never touch the process.

Contact us. Procurement, security review, invoicing, and larger rollouts can be scoped separately.

Solo includes 1 seat, unlimited repositories, 2 hours of active Vroni time per month, run history, pull request summaries, and the ability to buy top-ups.

Team includes unlimited seats, unlimited repositories, 10 hours of active Vroni time per month, priority queueing, tailored setup for your repositories, quarterly tuning updates, and top-ups.

Yes. Contact us if you need procurement support, security review, invoicing, or a larger rollout.

Yes. Team includes tailored setup for your repositories. On the flat rate, setup is fully handled by us.

Vroni needs access to the repositories you connect so it can implement tasks and open pull requests. You decide which repositories are installed through the GitHub App.

Yes. Repository access is controlled through the GitHub App installation and your GitHub organization permissions.

Yes. Vroni keeps task, run, pull request, credit, and activity records so teams can inspect what happened.

Yes. Task and run history is part of the product because it helps you understand what Vroni did, what it checked, and how Vroni time was used.

Do not put secrets in issues, comments, screenshots, or documentation. Vroni should use normal repository and CI configuration instead of receiving credentials in task text.

Vroni should not need production access for normal code edits. Keep production credentials and deployment permissions separate unless you deliberately configure a controlled workflow.

Use the contact page or email [email protected]. For the flat rate, include a short description of your product, repositories, and the tasks you want handled.

Vroni can report what is missing or ask for follow-up context. You can answer in the issue or pull request and continue the same task.

Yes. Contact us with your team size, expected workload, and whether you want self-serve Vroni runs or flat-rate delivery.

Public docs are not part of the launch version yet. The FAQ and onboarding flow cover the basics for now, and docs can be added once the product content is locked.

Yes. The FAQ will grow as more users join the waitlist, ask real questions, and start using Vroni on real repositories.