The app works. Shown to clients — approved. Shown to investors — impressed. Partner asked for access — logged in and didn't break it.

Then you open the code:

This is not funny. This is very typical. I see it in people I genuinely respect as professionals in their own fields.

I don't think this is bad. On the contrary — it's one of the most interesting stories happening right now.

AI has given domain experts a way to materialize their knowledge into software. This is literally a new superpower.

But there is a real difference between:

Between those states lies a non-trivial amount of engineering work. Not the “I'll rewrite everything because I know better” kind, but the kind where someone else's prototype is carefully unpacked into layers, so that what actually works is preserved and the meaning isn't lost.

If you are not a developer and you want to build a web app, the stack I usually suggest looks like this:

Do not overcomplicate things at the start. Docker on day one is an attempt to play “enterprise engineer” before you even have your first ten users.

Here is the move that people on the internet are already selling as a marathon course.

In a new empty project folder, create a subfolder refs/. Put everything you've already built with your previous AI iterations inside it: old code, prompts, screenshots, feature descriptions. Don't be shy — it's a reference, not the final product.

Next to it, put a REWORK.md file where, in your own words, you describe what should stay as is, what needs to be split into modules and components, what should move into business logic, what database you need, whether an admin area is required, and where it will be deployed.

  my-new-app/
  ├── refs/
  │   ├── old-prototype/        # everything from the previous AI build
  │   ├── screenshots/
  │   └── REWORK.md             # your plain-words rework brief
  └── (empty — agent will build here)

# REWORK.md

## What works — keep it
- UI flow for <main action>
- Core product logic in <area>

## What must be split
- Split UI into reusable components
- Move business logic into /services
- Extract data access into a data layer

## Data
- Entities: <list your objects>
- Need a real database (SQLite for MVP is fine)

## Access
- Roles: admin / user (and any custom roles from your domain)
- Simple auth is enough for now

## Admin area
- Yes / No, and what I must see there

## Deployment
- Vercel first
- VPS / Docker later, not now

## Non-goals
- No rewrite from scratch
- No enterprise ceremonies
- No new design

Then open this folder in Cursor or VS Code. For VS Code install the Claude (Anthropic) plugin, log in, open the chat. In Cursor it's already built in.

In the chat, write a prompt roughly like this (I keep code prompts in English — agents behave more consistently that way):

I have an early prototype in refs/.
Use it as a reference — do not copy code blindly.
Read REWORK.md in refs/ — it describes what I actually want.

Create a clean Next.js project with:
  - TypeScript
  - Tailwind CSS
  - App Router
  - shadcn/ui if UI components are needed

Split the UI into reusable components.
Move business logic into separate services.
Create a proper data layer.
Suggest a simple database (SQLite or Postgres) and wire it up.
Add a minimal admin area inside the Next.js app if it makes sense.
Don't over-engineer. Don't put everything into one file.

Before writing any code:
  1. Read the prototype in refs/
  2. Read REWORK.md
  3. Explain your plan in plain English
  4. Only after I approve — start coding

It sounds simple, but this one prompt turns a messy prototype into a properly structured project — as long as the agent has something to lean on.

Here I could, of course, say: “join my telegram, buy my course for $499, get three robots and eternal life as a bonus.”

I'm not going to do that. Instead — honestly and directly.

I can help if:

Not to “take your project” and not to rewrite everything from scratch because I supposedly know better. But so that what you've already built becomes a project you can keep moving forward with.

Right now the world isn't split into “developers” and “business.” It's split into those who can assemble a prototype themselves, and those who can turn a prototype into a system. Two different abilities — and both are needed.

That's it. Not selling a course. See you in the next post.