---
title: "We gave three non-developers AI coding tools"
url: https://makethin.gs/posts/non-developers-ai-coding-tools
author: Lyubomir Petrov
published: 2026-11-19
topics: [AI coding tools, AI]
tags: [claude-code, codex, non-developers, small-teams, dev-environments]
tldr: "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."
---

# We gave three non-developers AI coding tools

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 knew                    | What they did with it                                                                                                                  | What still needed checking                   |
| ----------------------------------------------------------------------- | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| **CEO** (a client of mine)                                              | Customers and their problems              | Built an integration that lets customers plug their AI tools into the product, now in production, plus a redesign and several features | Performance, testing, release planning       |
| **Designer** (Kalo, my co-founder at [Sensorhub](https://sensorhub.ai)) | How the product should look and feel      | Implements and refines the interface himself, prototypes new features                                                                  | Backend and data behaviour                   |
| **Salesperson** (at [FiberMan](https://getfiberman.com))                | Buyers, their objections, their workflows | Finds answers in the product himself, proposes fixes, later built his own CRM                                                          | Product details before they reach a customer |

### The designer who stopped waiting for me

This one is closest to my daily work.

At [Sensorhub](https://sensorhub.ai) 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.

**Figure — comparison of modes** _(interactive on the web page; data below)_

**One design change, two ways**

**Before:**

**[Flow]**

Nodes:
- He designs — in Figma (source)
- I implement — and leave the backend — highlighted
- He checks — fonts, spacing, colours (decision)
- Done

1. He designs → I implement
2. I implement → He checks
3. He checks → I implement: not yet
4. He checks → Done: ok

_Every round of feedback crosses from him to me and back._

**After:**

**[Flow]**

Nodes:
- He asks the agent — in his own environment (source)
- He checks the preview — the real running product (decision)
- Pull request
- Review — agent, plus a developer for larger changes — highlighted

1. He asks the agent → He checks the preview
2. He checks the preview → He asks the agent: not yet
3. He checks the preview → Pull request: ok
4. Pull request → Review

_He iterates alone. A review agent checks the pull request; a developer reviews the larger changes, mostly the parts that touch data._

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](https://getfiberman.com) 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.

**[Flow — One person's setup]**

Nodes:
- Their laptop — coding agent app, browser (source)
- Their own machine — code, test database, running app — highlighted
- Their running copy — shows each change
- GitHub — pull request (external)

1. Their laptop → Their own machine: secure connection
2. Their own machine → Their running copy
3. Their own machine → 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](https://makethin.gs/posts/ai-connected-to-whole-company), 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.

**Figure — step-by-step diagram** _(interactive on the web page; data below)_

**From a preview to production**

1. **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.)_
2. **2. Pull request, reviewed by a second agent.** A separate AI agent reviews the change with its own instructions. The agent that wrote the code does not grade its own work. _(Active: Contributor, Review agent. Contributor holds opens PR. Review agent holds reviews it.)_
3. **3. Fixes go back and forth.** Most routine review comments are fixed by the agents. A small change can be merged on the agent’s review; larger ones get a person’s review first. Where I am the reviewer, my own time goes mostly to the parts that touch the backend and data. _(Active: Contributor, Review agent. Review agent holds asks changes. Contributor holds fixes them.)_
4. **4. The team tests it together.** Changes land in a shared environment. If something breaks there, the fix goes through the same steps again. _(Active: Team. Team holds tests together.)_
5. **5. The team decides what ships.** Releases are deliberate and often batched. I look closer at anything that touches sensitive data, costly operations, the backend or database changes. _(Active: Team, Production. Team holds decides. Production holds released.)_

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.

> **Takeaway:** Anyone can experiment. The team decides what ships.

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

**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.
