Skip to content
LPmakethin.gs

We gave three non-developers AI coding tools

A CEO, a designer and a salesperson with almost no coding experience started building real software. What I set up, what they built, and what went wrong.

Lyubomir Petrov
A simple vector graphic of a toy robot helping a human stack colorful building blocks on a desk.
TL;DR

I gave a CEO, a designer and a salesperson each an isolated copy of a product, an AI coding agent and a preview link. Over the following months that grew into an integration now in production, a redesigned product and, on one colleague's own initiative, a self-built CRM. They did not become programmers. A separate review agent, shared testing and a team decision still stand between a preview and production. The real problem was scope: they wanted to build everything.

What gets sent to the assistant

Summarize: “Summarize this article by Lyubomir Petrov in 5 bullet points, then list the 3 strongest claims and how I could check them: https://makethin.gs/posts/non-developers-ai-coding-tools.md”

Open: “I'm reading “We gave three non-developers AI coding tools” by Lyubomir Petrov (https://makethin.gs/posts/non-developers-ai-coding-tools.md). Read it, then help me apply it to my situation. Start by asking me 2 questions.”

Ask about a section: “Read https://makethin.gs/posts/non-developers-ai-coding-tools.md and focus on the section “{{heading}}”. Explain it and how it applies to me.”

On this page · 7 sections
  1. Who were the three, and what did they build?
  2. What did I actually give them?
  3. Did they have to learn programming first?
  4. How does a preview become production?
  5. What went wrong?
  6. What changed for me?
  7. Would I do it again?

A while ago I was consulting for a small software company, and its CEO asked me something I didn't expect:

"Could I actually start coding myself?"

He talks to customers all day and runs the company. His background is not software. I thought: why not try.

I set up a working copy of the product for him, put an AI coding agent in front of it and gave him a real task. No programming course. The product does not run on his laptop. He asks for a change and looks at the result in his browser.

A few months later he had built a large integration that is now in production.

Then I started joking with my own co-founder Kalo, a designer and marketer, about the CEO who can't stop building. Maybe you should try it too. We stopped joking and I prepared the same setup for him. After that, our sales colleague at a third product started building as well.

Three people, three products, almost no programming experience. I didn't teach them to think like developers. I gave them a way to build while they keep thinking like a CEO, a designer and a salesperson.

In this post you'll learn
  • What a CEO, a designer and a salesperson built once they could try things themselves
  • The setup I gave them, and how long it takes to repeat
  • How a preview becomes production, and who decides
  • The problem I did not expect: they wanted to build everything

Who were the three, and what did they build?#

What they already knewWhat they did with itWhat still needed checking
CEO (a client of mine)Customers and their problemsBuilt an integration that lets customers plug their AI tools into the product, now in production, plus a redesign and several featuresPerformance, testing, release planning
Designer (Kalo, my co-founder at Sensorhub)How the product should look and feelImplements and refines the interface himself, prototypes new featuresBackend and data behaviour
Salesperson (at FiberMan)Buyers, their objections, their workflowsFinds answers in the product himself, proposes fixes, later built his own CRMProduct details before they reach a customer

The designer who stopped waiting for me#

This one is closest to my daily work.

At Sensorhub we were working on an improved version of the product. I was deep in the backend: data, integrations, the parts nobody screenshots. Kalo was designing the interface, which is what he is very good at.

The old way looked fine on paper. He designs in Figma. I implement it with AI tools. We compare.

Then came the details. A font size a bit off. A gradient not quite right. Spacing, colours. He tests and sends feedback, I change it, he tests again. Nothing wrong with his design or his feedback. Design needs many quick rounds, and sending each one through me was slow for both of us.

Switch between the two setups below.

Compare
One design change, two ways
not yetokHe designsin FigmaHe designs — in FigmaI implementand leave thebackendI implement — and leave the backendHe checksfonts, spacing,coloursHe checks — fonts, spacing, coloursDoneDone

Flow with 4 nodes: He designs, I implement, He checks, Done. Connections: He designs to I implement; I implement to He checks; He checks to I implement (not yet); He checks to Done (ok).

Flow with 4 nodes: He designs, I implement, He checks, Done. Connections: He designs to I implement; I implement to He checks; He checks to I implement (not yet); He checks to Done (ok).

Every round of feedback crosses from him to me and back.

Setup: Before. Every round of feedback crosses from him to me and back.

The cost was never only the implementation time. Two people kept waiting for each other.

Engineering did not go away. At Sensorhub, for complex features I still review the backend and the data behaviour and fix what needs fixing. A prototype needs backend and data work before it can be sold.

And the result was not a nicer version of the old product. The plan kept growing: one feature became a few, then a redesign. What we call Sensorhub V2 is in many ways a new product. As I remember it, that push took three to four months. When we opened it for alpha testing, the feedback we heard kept praising the design. That credit goes to him. The eye and the decisions were his. AI gave him a direct way to build them.

The CEO who built an integration I didn't expect#

The CEO understood the product's rough edges because customers told him about them directly. Before, he had to describe a problem to a developer and wait.

With his own environment he could work on it himself. The example that still surprises me is an integration.

The product had an old API that covered only part of what the web app can do. Customers were asking for MCP, a way to plug their own AI assistants into a product. The first idea was modest: expose the old API through MCP. I helped with the first prompts, and we talked early about performance, debugging and how people would really use it. He continued from there: testing, prompting, adjusting. What he ended up with supports most of what the web app can do, including many things the API never had.

That does not mean no engineer was involved or that everything could ship untouched: their own developer reviewed the work. It means someone who knows customers but not programming carried a technically hard feature much further than I expected.

A few weeks after my work there ended, he messaged me. He had finished more of the integration and several features, they were preparing to launch, and he joked that he had barely slept for two weeks. Not sleeping is not a goal. But I loved how proud he was of what he had made. The integration is in production now.

The salesperson who built a tool I thought I'd have to build#

At FiberMan our sales colleague was learning a complicated product. Early on he often asked me where something was, whether a feature existed, or how it behaved.

With AI access to the code and a running copy of the product, he could find many of those answers himself. He started proposing small fixes and prototypes. He also checks what the software really does when he prepares outreach and offers.

Then he went further than my setup. One day he told me he had built his own CRM, with lead enrichment, scoring and tracking. I had assumed I would have to build that for him at some point.

He built it on his own computer, with his own AI tools, not in the environment I gave him. That environment showed him what was possible. He took the idea into his own work. I'm fine with that: it is a small tool for basic things, and nothing critical depends on it at this early stage of the company.

What did I actually give them?#

Less than you might think, and more than an AI subscription. I removed the engineering setup from their day.

Diagram
One person's setup
secure connectionTheir laptopcoding agent app,browserTheir laptop — coding agent app, browserTheir ownmachinecode, testdatabase, running…Their own machine — code, test database, running appTheir runningcopyshows each changeTheir running copy — shows each changeGitHubpull requestGitHub — pull request

Flow with 4 nodes: Their laptop, Their own machine, Their running copy, GitHub. Connections: Their laptop to Their own machine (secure connection); Their own machine to Their running copy; Their own machine to GitHub.

Flow with 4 nodes: Their laptop, Their own machine, Their running copy, GitHub. Connections: Their laptop to Their own machine (secure connection); Their own machine to Their running copy; Their own machine to GitHub.

Simplified. Each person has a separate machine and a separate development database. These machines cannot reach production. A change gets there only through review and a release.

Each person got an isolated machine with that project's code, a development database and the app already running. They connect to it from a desktop coding agent (Claude Code or Codex, depending on the person) and open their running copy in the browser to see what changed. When they want to show someone, one command publishes a preview they can share.

The first setup was clunkier. The CEO started in a terminal, which felt scary for a day or two. Later the desktop apps with remote sessions made it much friendlier. The three setups are almost the same. What follows is Kalo's, the one I have refined the most.

What is in the sandbox#

  • His own machine. An isolated environment with its own database, test users already in it, and a private address where his copy of the app runs. It is cut off from production and from every other environment.
  • No terminal. He connects over a secure connection with the Claude desktop app, which works directly in the project folder on that machine.
  • A shared folder. It shows up as a normal folder on his Mac. The agent drops mock-ups and screenshots there, and looks there when he says "I uploaded a file".
  • Secrets stay out of reach. The real keys for outside services are not readable by him or by his agent session.
  • The heavy work runs on the server. His laptop does not run the product.

The standing instructions#

The project tells the agent how to behave, in ordinary files it reads every time (CLAUDE.md, AGENTS.md). The important ones:

  • Work only on your own branches. Never touch the main ones, never merge, never force anything.
  • The default scope is layout, styling, text, accessibility and frontend tests. Ask before touching the backend, the database structure, login, billing, dependencies or analytics.
  • Check desktop and mobile, and the loading, empty, error, hover and focus states.
  • Run the real checks (lint, types, tests, build). Never hide or skip a failure.
  • Treat configuration files, keys, database dumps and logs as secrets.
  • Plan first. He reads the plan before anything changes.

Five commands instead of Git#

He never types a Git command. The workflow is five commands he can run by name:

  1. Start a change. Refuses to start if earlier work is unsaved, then creates a fresh branch from the latest base.
  2. Deploy my preview. Looks at every changed file, stops on anything unexpected, runs quick checks, saves, and deploys to a preview link he can share.
  3. Where am I? A read-only answer: which branch, what is saved, what is deployed, is it healthy, is there a pull request.
  4. Submit for review. Opens one pull request with a fixed template: what changed, why, how it was checked, the preview link, which screens were looked at. It never merges.
  5. Catch up with the base. Pulls in everyone else's work. On a conflict it stops and reports. It does not try to resolve it.

The preview link matters more than it looks. Being able to send a colleague a link to the thing you just built, without asking anyone, is a big part of why this works.

Guardrails that do not depend on the AI behaving#

Instructions are requests. These are not:

  • Protected branches are enforced on the machine, outside the agent's reach. A push to one is rejected.
  • Privileged actions are a short, fixed list, such as deploying a preview and looking at its status.
  • The deploy script checks everything again by itself: branch, install, types, lint, build, tests. Then it backs up the database, applies changes, switches the release and checks that it is healthy. If anything fails, it puts the previous release back. These limits are there for the agent, not for the person: an AI agent should not be able to do those things from anyone's session.

Review is the one step that depends on judgement, and on the project. Every pull request gets the review agent. How closely a person looks depends on the change: a small one can go through on the agent's review, while larger changes, and anything that touches data, a developer reviews and sometimes fixes. At Sensorhub that person is me; for the consulting client it was their own developer. Other projects set the bar differently.

What broke along the way#

  • On one project a preview takes 20 to 45 minutes, because it is a full deployment that runs every check. On another it is a link to a development server and shows a change immediately. That is longer than a single agent step can wait, and early deploys were cut off halfway. The command now starts the deploy in the background and checks on it.
  • A killed deploy looked like a success. The command now spells out what success means: the deployed version matches, the result says successful, the health check is green.
  • Running the full tests locally and again in the deploy made every preview feel endless. Now only quick checks run locally.
  • A run passed every test and then failed the build. The deploy now builds before it tests.

If I set this up for someone tomorrow#

  1. Make the environment isolated and disposable. Their own app, their own development data, their own preview. Nothing that can affect real customers.
  2. Prepare the project for an agent. Write down how to run, test and deploy it. Put repeated operations into skills or scripts.
  3. Give them a friendly interface. A desktop coding agent and a browser preview, not Docker and Git on day one.
  4. Start with a real, small task. Something they can judge with what they already know.
  5. Keep production behind separate checks. Being able to make a working preview is not the authority to ship it.

Time and cost#

  • Setup time. With a project I have already prepared, I can give another person the same environment in about 20 to 30 minutes with a couple of prompts. That is not a claim about an unfamiliar application: the first setup of each project needed two to three weeks of small fixes. After that I remember two or three small interventions over five to six months.
  • The machine. About €30 to €60 a month per person, depending on whether the project needs 8 or 16 GB of memory. Those are prices from 13 October 2026. Memory prices are high and change often.
  • Disk space. More than you expect. Agents keep a separate working copy for every prototype, and people run two or three prototypes at once and pause some for weeks. How much you need depends on the size of the project and what its build produces.
  • The AI subscription. A $200 Claude subscription for each person who uses Claude. Our sales colleague uses Codex on his own plan. Each of them works with the agent themselves, in a session they started, which is what a personal subscription is for.

The times are my recollections, not measurements.

Did they have to learn programming first?#

No. All three started with close to zero coding experience.

They had one advantage. We already used a shared AI agent in Slack, so they were used to asking "why isn't this working?" before assuming they had to work it out alone. And when the AI could not help, they asked me or another developer. They knew AI could help and they knew who to ask next. That was everything they needed.

I did not run a training. I have trained people professionally, and I think the fastest way to learn is to do something real in a safe place. So that is what they got: a safe place and a real task. I usually started them with a bug to fix, then a small improvement. After that they followed their own ideas and the backlog. As I remember it, each of them made a useful contribution within one to three days, in some cases on the first day.

How their requests changed over the first months:

  1. Ask for a change. "Change this button." "Fix this page." Then look at the preview.
  2. Give context. Screenshots, files, an example, the result they want.
  3. Plan first. Ask the agent to investigate before changing anything, use planning mode, write a short spec.
  4. Extend the setup. Add a skill or connect a tool when it helps.

They did not become good at reading code, and they still leave most low-level technical decisions to the AI. Every change goes through review before release. How much of that reaches me depends on the project: on some, the backend and data parts come to me regularly; on others, a decision comes to me only now and then for a final look or an improvement. What improved is how they direct it, how they judge the result with what they know about customers, design or sales, and when they ask for help.

How does a preview become production?#

This is where I disagree with "just give them Claude Code". A working screen is not a working feature. A working feature on its own is not safe to release into a product with real data and customers.

Step through what happens to a change.

Step through
From a preview to production
  1. Contributor
    own environment
    tests it
  2. Review agent
    separate instructions
  3. Team
    shared test environment
  4. Production
    batched releases
1. They test their own work

In their own environment, with their own data. They see it, use it and correct it before anyone else is involved.

Step 1 of 5. 1. They test their own work. In their own environment, with their own data. They see it, use it and correct it before anyone else is involved. Active: Contributor. Contributor holds tests it.

Parts of these products have thousands of tests, so the automated checks take time. That cost is real whether a person or an agent wrote the code.

The process is there to make contributing easy. It does not pretend review and testing are optional.

What went wrong?#

The moment they understood what they could do, they went a little wild.

The CEO took on a redesign and several large features in the first month or two. At Sensorhub a modest improvement turned into a new version. Our sales colleague began building internal tools as well, so we talked about how to balance that with selling.

I understand it completely, because I do it too. When you can make something interesting quickly, it is very hard to stop.

The ideas were not the problem. The cost of making a prototype fell much faster than the cost of releasing and maintaining it. Five new features are exciting. They are also five more things to integrate, test and keep working.

At first, release planning could not keep up with how fast we could build. We did not fix it by banning experiments or adding another approval layer. We talked. After a few demanding release cycles we all understood the cost.

That applies to my experiments too. Some prototypes become features. Some go to the backlog. Some stay experiments. All three are fine.

I want people to be curious. I want a startup to be a place where someone says "I wonder if I can build this" and finds out. The discipline is in deciding together which experiments deserve the scarce time that testing and releasing take.

What changed for me?#

I was the technical person in the middle of all three stories. Even with AI helping me code, I was the one turning everyone's ideas into working changes: design handoffs, product questions, sales requests.

Now people explore an idea, test it and bring me something concrete. When I am needed, it is more often for architecture, backend correctness, a difficult review or a decision about what to integrate.

I have no measured multiplier and I would not trust one I made up. I can say what changed in my calendar: far fewer design handoffs, fewer questions colleagues can now answer themselves, and more time for the problems that need me. That means development workflows, internal AI tools, infrastructure and product costs, strategy and funding.

And more time for myself and my family. That counts too.

Would I do it again?#

Yes, without hesitating. With a few rules:

  1. Prepare the isolated environment before asking anyone to build.
  2. Make the result easy to see. A preview link beats any explanation.
  3. Write down how the project is tested and deployed. The agent reads it every time.
  4. Use capable coding models and a separate review.
  5. Start with a real, manageable task. Not with watching me work.
  6. Have the conversation about scope early. Before everyone finds out how addictive building is.

One limit, said plainly: this is not proof that any non-developer can safely take over a large production codebase. Each of these projects had a technical person preparing the environment, a separate review step and people deciding what gets released. In products that handle a lot of data, those safeguards matter a lot.

I expected AI to help us write code faster. What surprised me is how much it changed who can make things, and how excited they got when they noticed.

If you have tried this with someone on your team, I would like to hear how the scope conversation went.

Questions and answers

Short answers to what readers ask about this post.

Do non-developers need to learn programming before using an AI coding agent?

In my three cases, no. They started with close to zero coding experience and made useful contributions within one to three days, as I remember it. They got better at directing the AI, not at reading code.

What do you need to set up for them?

An isolated machine per person with the project's code, a development database and the app already running, a desktop coding agent connected to it, a private preview link, and project files and commands that tell the agent how to run, test and deploy.

How long does the setup take?

For a project I have already prepared, about 20 to 30 minutes per extra person. The first setup of each project needed two to three weeks of small fixes. Both are my recollections, not measurements.

Which tools did they use?

Claude Code or Codex, depending on the person, through the desktop apps with a remote session. The first setup used a terminal, which was harder to start with.

Can they release to production on their own?

No. They can deploy to their own private preview link and share it with colleagues, which matters a lot. For production, a separate AI agent reviews every pull request. Larger changes, and anything that touches data, also get a developer's review; a small change can go through on the agent's review. The team tests changes together and decides what is released.

Do they work on real customer data?

No. Each person has a separate development database on their own virtual machine.

What was the biggest problem?

Scope. Once they could build, they wanted to build everything. Making a prototype became much cheaper than testing, releasing and maintaining it. Our rule now: anyone can experiment, the team decides what ships.

What does it cost per person?

A machine for about 30 to 60 euros a month (prices from 13 October 2026, for 8 or 16 GB of memory) plus an AI subscription. For the Claude users that is a 200 dollar plan each.

How big does the machine need to be?

For many full-stack apps, roughly 8 to 16 GB of memory per person, and a lot of free disk space: agents keep a separate working copy for every prototype. Both depend on the size of the project.

Was this worth your time?
Get new posts by email

AI, engineering and how work is changing. No spam.

New posts only, roughly twice a month. Unsubscribe with one click.

Keep reading

More in AI coding tools · AI · claude-code · codex

Author
Photo of Lyubomir Petrov
Lyubomir Petrov
CAIO/CTO & co-founder · FiberMan · Sensorhub