AI coding agent for everyone: introducing Buildful

Buildful is an AI coding agent for everyone. You describe a change to your app in plain words, the way you'd explain it to a friend who codes. Buildful writes the code in a private sandbox in the cloud, runs your project's checks, tests any screen it changed in a real browser and records the test, then opens a pull request on your GitHub repo: a change you review, then merge. Pro costs $10 a month for 1,000 tasks, about a cent a task, and the Free plan gives you 3 tasks to try it first.

My co-founder Fazle and I are building it because the best AI for writing code sits behind plans that cost $100 to $200 a month. For most people who want to build software, students, freelancers and first-time founders all over the world, that isn't a price. It's a wall. We don't think coding superintelligence should be a luxury, so we built Buildful for everyone who's been priced out.

What is an AI coding agent?

An AI coding agent is software that takes a goal, like "add a dark mode", and does the work itself: it reads your code, plans the change, edits files, runs your tests and fixes what breaks, then checks its own work before handing it back.

It works in a loop: read, plan, change, check, fix, and repeat until the checks pass.

You'll run into three kinds of coding tools that use AI:

1. Chat assistants answer with code. You copy it, paste it, run it and fix it yourself.
2. Agents in your editor or terminal, like Cursor, Claude Code, Codex CLI, OpenCode and Copilot's agent mode, edit files on your own computer while you watch and steer.
3. Background coding agents work somewhere else, on their own, and come back with finished work for you to review. Buildful is this kind of AI coding agent.

The third kind asks the least of you. There's nothing to install and nothing to watch: you describe the change and judge what comes back. You still need your code on GitHub, and someone to set up the repo once. If you like driving, an editor agent will suit you better, and plenty of developers use both.

Who does the work, and where, in each kind of AI coding tool.

What actually happens when you hand Buildful a task

You do two things: describe the change, then review the result. Everything in between, from writing the code to testing it in a browser, happens in a private sandbox in the cloud, and you don't have to watch it.

1. Connect GitHub. Sign in with Google or with an email and password, install the Buildful GitHub App, and choose which repos it may work on.
2. Give it a task. Write what you want in plain words, at least a sentence. Pick one repo or several (a task can change your website and your API together). For a single repo, choose the branch to start from. If a picture explains it better, attach screenshots.
3. Buildful picks the model and builds. Smart Mode, the part of Buildful that chooses the AI model, reads your task and picks an open-weight model for it: a model many companies can run, which keeps the price low. A fresh copy of your code goes into a sandbox and the agent starts work. You can close the tab and the task keeps running.
4. Your checks run, and failures get fixed. If a check fails because of the change, the agent fixes it and runs the checks again, up to 3 attempts. Then it re-reads its whole change the way a skeptical reviewer would.
5. It gets tested in a real browser. If the change touches something people see, the agent starts your app, opens it in a browser, uses the feature the way a person would, and records the session.
6. You get a pull request per repo. Each comes with a summary, the self-review, what was checked, what wasn't, and the recording.
7. Follow up, then merge. Reply on the task to ask a question or ask for changes, and the new commits land on the same pull request. Follow-ups don't count as new tasks. Merge when you're happy.

You can also just ask a question about your code, like "where do we send the welcome email?", and the agent answers without changing anything. And if a request turns out to be impossible or a bad idea, the agent is told to change nothing and explain why.

Step 1: you choose which repos Buildful may work on.

Step 2: the task box, with a repo, a branch and an attached screenshot.

Who we're building it for

Buildful is for the next 100 million people who'll build software: students, freelancers, first-time founders and small teams, most of whom will never pay $200 a month for an AI plan.

We spent years building Hashnode for developers all over the world. Many of them learned in public, and most didn't have a budget for expensive tools. Today the strongest AI coding tools sit behind plans like Factory Max at $200 a month and Claude Max from $100. For most of the world, a plan priced like that isn't a choice you get to make.

So these are the people we have in mind:

• A student building a final-year project or a first app. Every change arrives as a pull request they can read line by line and learn from.
• A freelancer for whom a client's small fix is one task out of 1,000 in a month, not a slice of a $200 bill.
• A founder with an idea and no team yet, who describes a change, watches the recording, and merges.
• A small team that wants the same tool for everyone on one bill. Team is $40 a month, however many people join.

You don't have to be an experienced developer, but it helps to know some code when you read the change. For screen changes you can watch the recording either way, though a recording shows that the screen works, not how good the code behind it is.

You need a GitHub account with your code in a repo, and the repo set up once so Buildful can start your app (more on that below). If you don't code, a developer friend can do that setup for you.

You get the proof along with the code

Every change runs your checks, and every UI change is tested in a real browser and recorded. That gives you what I call an evidence-backed pull request: a change that arrives with its own proof, so you can judge it before you read a line of code.

The agent is instructed to write every pull request description in the same four parts:

• Summary: what changed and why.
• Self-Review: what it looked for in its own change, each defect it found and fixed and why it was wrong, or "No defects found" if the change held up.
• Verification: each check it ran, whether it passed, and what it did in the browser.
• Caveats: anything it couldn't verify. It's told never to claim more than it checked.

Below those sits a preview of the browser recording, with a link to watch it in Buildful. The recording also plays in the task view, so you can review without leaving the app.

The checks are your project's own, the ones you set up for this repo. When one fails because of the change, the agent gets up to 3 attempts to fix it. If a check still fails after that, Buildful opens the pull request anyway, and the pull request tells you which check failed and why. We don't hold the pull request back, because you're the one who decides what merges, and a clear "this check still fails, here's the error" is more useful than a task that silently never finishes. Checks that were already failing before the change get noted too. The agent doesn't touch them and doesn't hide them.

The browser test has rules. The agent has to use the feature: click the buttons, fill in the fields, submit the form, then confirm what changed on screen. Opening the page and seeing that it loads doesn't count. Neither does checking the result behind the scenes, say by reading the database directly instead of looking at the screen. The recording opens each stage with a short title card saying what's about to be tested.

Sometimes the agent can't test. If your app won't start in the sandbox, for example because an environment variable is missing, it skips the browser test and says so under Caveats. I'd rather read "couldn't test this, here's why" than a confident claim nobody checked, and that kind of plain reporting is what lets me trust the rest of the description.

Checks first, up to 3 fix attempts, a self-review, then a browser test if a screen changed.

What an evidence-backed pull request looks like on GitHub.

Each stage of the recording opens with a title card.

The one-time setup

Each repo gets a short settings sheet that tells Buildful how to install, check and sign in to your app. Every task on that repo uses it.

In Repos, open Configure on any repo. You can set:

• The base branch, and the working folder if the repo holds more than one app.
• Setup commands: how to install and start your app.
• Check commands: which tests and code-quality tools to run.
• Notes for the agent, your house rules, like "use our Button component".
• Environment variables, stored encrypted and shown masked. Use staging or test values here, never production ones.
• A captured login, so the browser test starts already signed in to your app.

The settings sheet each repo gets. The values here are examples.

Here's a real task from our own repo

On October 3, Fazle asked Buildful for a change to our own dashboard. The agent made the change, caught and fixed its own mistake before any checks ran, then came back with the checks run, a pull request, and a 4 minute 41 second recording of the new feature being used.

We build Buildful with Buildful. The repo is private, so I can't link the pull request (#206), but everything below is copied from the task and its pull request.

This is the request, exactly as Fazle typed it:

show task creator's name in the recent tasks in the dashboard home only if it's a team setup. also add a filter on the top to filter by team member - in team setup.

Lowercase, two sentences, no file names. That's what most requests look like, and it was enough.

Smart Mode picked the model, a sandbox started with a copy of the repo, and the task view filled with the agent's notes as it worked: "Now the API route and the search hook", then "Now the member filter select, next to the repo one".

Halfway through it made a mistake and noticed it: "The edit landed in the wrong </div>. Fixing." Its self-review in the pull request explains it in full: the first edit put the new filter inside a task row instead of next to the repo filter, so it re-read the file, undid the edit and put the filter in the right place, before any checks ran.

The first version changed five files. Here is what it reported:

• Checks. The type check passed. Lint reported 6 problems, all in files the change didn't touch, and the agent said so rather than quietly fixing or hiding them. The repo has no test suite, and it said that too.
• Browser test. It signed in, opened a team with two members, checked that every task showed who created it, and used the new filter: one member returned 50 tasks, the other returned none. Then it switched to a one-person team to confirm the name and the filter disappear there.
• Caveats. The one-person team had no tasks to show, so the agent created a temporary one for the test and deleted it afterwards, and wrote that down. It also noted that it checked combined filters by reading the code, not in the browser.

The recording runs 4 minutes 41 seconds and plays right in the task view, next to the pull request.

How we got 1,000 tasks down to $10

We sell tasks, not models. Smart Mode reads each task and picks an open-weight model for it, with a quick pass for a small fix and more time to think for a hard one. Not every task needs a frontier model, the biggest models from labs like Anthropic and OpenAI, and that's how $10 covers 1,000 tasks.

Start with the arithmetic. $10 for 1,000 tasks is about a cent a task. Team works out the same way: $40 for 3,000 tasks is a little over a cent each. Extra blocks are $10 for another 1,000.

That price is possible because of what the work runs on. AI companies charge by the token, a small piece of text, roughly three quarters of an English word. Open-weight models are published openly, so many companies compete to run them, and their prices show it. When we compared public list prices on September 24, 2026, two frontier models charged $10 and $20 per million output tokens. Three open-weight models charged between $0.42 and $2.64. That puts the frontier models at roughly 4 to nearly 50 times the price. Open-weight doesn't always mean cheap, though: one open-weight model we looked at costs more than a frontier model. These are list prices, not what Buildful pays.

To be precise about what ships today: Smart Mode makes its pick per task, not step by step, so one model does the whole job. A follow-up gets its own look, since it's a new request. Every task included in your plan runs on an open-weight model. Smart Mode doesn't hand any part of a task to a frontier model. A typo fix in the footer gets the quick pass; a rebuild of your billing page gets more time to think. Each one counts as 1 task. If routing changes, we'll announce it on this blog first, then update this post.

We don't publish which models Smart Mode uses, and we change them as better ones ship.

You pay per task, not per token, so before you send a change you already know what it uses: one task.

Smart Mode picks one open-weight model per task. Frontier models are a separate choice you make yourself.

Still want Claude or GPT? You can pick them

On Pro and Team you can pick a frontier model yourself, like Claude or GPT, with prepaid credit or your own API key.

Smart Mode is the default on every plan, and on Free it's the only option. On Pro and Team, the agent picker in the task box also lists Claude Code with Opus 5.5, Sonnet 5.5 or Fable 5.1, Codex with GPT-6 Astra, GPT-6.1 Sol or GPT-6 Luna, and Grok Build. You pay for those in one of two ways:

• Prepaid credit. Top up from $5 on the Billing page, and the task draws from it.
• Your own API key. Add a key from OpenAI, Azure OpenAI, Anthropic or xAI. It's stored encrypted, and the usage is billed to your account with that provider.

On Pro and Team, the picker adds coding agents from other AI labs.

The rest of what it does

Tasks can start outside the dashboard, run side by side, and share what Buildful learns about your repo.

Hand off several things at once

Every task gets its own sandbox, so tasks run side by side without waiting on each other. The task list shows where each one stands: Queued, Running, PR opened, PR merged, Completed, Failed or Stopped.

Start in Slack or Linear

In Slack, type /buildful or mention @Buildful with your request. If Buildful is confident which repo you mean, it starts. If not, it asks. Either way it replies with a link to the task. In Linear, add the label you chose to an issue and it becomes a task on the repo you picked, and when the pull request opens, it gets attached back to the issue.

It remembers what you merged

After each task, Buildful notes short facts about your repo, like which command builds it or where the styles live. When you merge the pull request, those facts become active, and up to five per repo go into the next task's instructions. There's no screen to view or edit them yet.

Bring your team

On Team, invite as many teammates as you like. You share repos, tasks and what Buildful has learned, on one bill. A team switcher in the sidebar moves you between teams.

Nothing to install

Everything runs in the cloud, so any browser works, including the one on your phone. If you're a developer and want to try a change locally, a single-repo task gives you one preview command (npx buildful preview).

The same task box on a phone.

Changed your mind? Stop it, retry it, or reply

Stop a task while it runs, retry one that failed, or reply to steer it. Small things: light, dark or system theme, and keyboard shortcuts (⇧N for a new task, ⌘⏎ to send).

What it costs: free to try, then $10 a month

Free gives you 3 tasks to try Buildful. Pro is $10 a month for 1,000 tasks. Team is $40 a month for 3,000 tasks shared by unlimited teammates. On Pro and Team you can add 1,000 more tasks for $10 any time.

Team isn't a bulk discount. Per task it costs about the same as Pro. What it adds is teammates and more tasks. The price stays $40 however many people join.

When you run out of tasks, new tasks pause until you add a block of 1,000 for $10, paid up front. There's no overage bill at the end of the month. Prices are in US dollars, and checkout goes through Stripe.

For scale, here's what other tools charge, from their pricing pages on October 5, 2026: Factory Max is $200 a month. Buildful is $10. Claude Max starts at $100. Some other tools cost $10 too: GitHub Copilot Pro is $10 of AI credits, and OpenCode Go is $10 for open-weight models you use with your own agent. Each plan includes different things, so compare what you get back, not only the price. The full breakdown is on Buildful pricing.

What happens to your code

Every task runs in its own private sandbox, and the sandbox is destroyed when the task ends. The change reaches your main branch only when you merge it.

Your keys and environment variables are encrypted at rest. When a task starts, they're injected into the sandbox dedicated to that task, and they're gone when the sandbox is destroyed. The work happens on a new branch, so nothing changes in your app until you merge the pull request.

How it stacks up against Claude Code, Cursor and the rest

Pick an editor agent if you like steering the work yourself. Pick Buildful if you'd rather describe the change and come back to a tested pull request on your own repo.

If you already pay for Claude or ChatGPT and like driving an agent in your own terminal, stay there. If you want AI suggestions inside the editor you use all day, Cursor or Copilot fits that. If your app lives in Lovable's or Replit's workspace and you're happy with them hosting it, that's a fine place to build. Buildful fits when your code is in a GitHub repo and you'd rather hand off the change and review it later.

You can also use both. Buildful only opens pull requests on your repo, so it sits fine next to Claude Code or Cursor on the same project. There's a page per tool on how Buildful compares.

Why we're building Buildful

We set the price first, $10 for 1,000 tasks, and built everything else to fit inside it.

Why us? Buildful comes from the makers of Hashnode. I co-founded Hashnode and was its CTO. At Bug0, where I look after the core infrastructure and technology, we test web apps with AI from end to end. That's where Buildful's rule comes from: every UI change gets tested in a real browser and recorded before you see it. About Buildful has more on who we are.

The bet is the one from earlier: we sell tasks, not models. A routing layer lets the work run on open-weight models, and that's what makes about a cent a task possible.

We chose a pull request over a chat window on purpose. A pull request is real code in your own GitHub, which you can read, keep, change and ship anywhere. If you stop using Buildful, the code you merged stays in your repo.

What Buildful can't do yet

Here is what Buildful doesn't do today, so you can decide knowing the gaps.

• Smart Mode picks per task (and again for each follow-up), not per step, and it never hands work to a frontier model. Frontier models are there only when you pick one.
• It works on GitHub repos only. You need a repo, and Buildful doesn't host your app.
• The browser test needs your app to start in the sandbox. That takes setup commands, environment variables, and for signed-in pages, a captured login. When it can't start, the pull request says so.
• You can't view or edit what Buildful has learned about your repo yet.
• Every pull request still needs a person to review it. That's by design.

Frequently asked questions

What is Buildful? Buildful is an AI coding agent. You describe a change in plain words, and it hands back a tested pull request on your GitHub repo, with your checks run and every screen change tested in a real browser and recorded. The Free plan includes 3 tasks, and Pro is $10 a month for 1,000.

What is an AI coding agent? Software that takes a goal, like "add a dark mode", and does the work: reads your code, plans, edits files, runs your tests, fixes what breaks, and checks its own work before handing back the result.

Which AI agent should I use for coding? It depends on how you like to work. If you code every day and want to steer each step, use an editor or terminal agent like Cursor, Claude Code, Codex or OpenCode. If you'd rather describe the change and review a finished, tested pull request, use a background agent like Buildful.

Is there a free AI coding agent? Yes. Buildful's Free plan gives you 3 tasks to try it, and Pro is $10 a month for 1,000. Open-source agents like OpenCode are free to install, though you pay for whichever model you connect.

Who are the big 4 AI agents? There's no official list. People usually mean the coding agents from the four biggest AI vendors: OpenAI (Codex), Anthropic (Claude Code), Google (Gemini Code Assist and Jules) and Microsoft (GitHub Copilot). Plenty of others, Buildful included, come from smaller teams.

What's the difference between an AI coding agent and an AI coding assistant? An assistant suggests code while you type. An agent takes a whole task, checks its work and hands back the result.

How much does Buildful cost? Free is 3 tasks. Pro is $10 a month for 1,000 tasks. Team is $40 a month for 3,000 tasks shared by unlimited teammates. On Pro and Team, add 1,000 tasks for $10 any time.

Does a follow-up count as a new task? No. A follow-up continues the same task and adds commits to the same pull request. Follow-ups don't count as new tasks.

What if a check keeps failing? The agent gets 3 attempts to fix a check its change broke. If it still fails, the pull request opens anyway and tells you which check failed and why, so you can decide what to do.

Can I use Claude or GPT with Buildful? Yes, on Pro and Team. Pick a frontier model yourself, like Claude or GPT, with prepaid credit (top up from $5) or your own API key. The tasks included in your plan run on the open-weight model Smart Mode picks.

Do I need to know how to code? Not to ask for a change: you describe it in plain words, and it arrives as a pull request, a change you review, then merge. You do need your code on GitHub and the repo set up once so Buildful can start your app. Knowing some code helps you review the change. For screen changes you can watch the recording, which shows the screen works but not how good the code is.

Does Buildful work with my existing project? If it's on GitHub, yes. Connect the repo, tell Buildful once how to install and check it, and start.

Is my code safe? Each task runs in a private sandbox that's deleted when the task ends, and nothing reaches your main branch until you merge. Environment variables you add go into the sandbox so your app can run, so use staging values.

Can students use Buildful? Yes. You need a GitHub account and a repo.

Start building

Connect a GitHub repo, describe one change, and see what comes back.

Pick something small and visible for your first task, like a typo on your homepage or a button that should be a different color. It's easier to judge the result when you already know what it should look like.

Start building · or, for a team, Go Team