Dieser replizierbare AI-Arbeitsablauf ermöglicht es nicht-technischen Projektmanagern, Produkte von Grund auf zu entwickeln.

You think that to develop products, one must first be able to program.

But recently, a product manager without technical knowledge developed an AI tool that was launched and made profits. Even professional engineers asked him: How did you manage to do that?

The protagonist is Zevi Arnovitz, a PM at Meta. In high school, he played music and studied psychology and has never written a line of code. He says:

When I first used an AI programming tool, I felt like a superhero.

He actually managed to do it. He assembled a team with AI: He assigned different AI systems tasks such as architecture, design, and debugging and then let them cooperate with a programming tool. The resulting product, StudyMate, was launched and is making profits.

His approach: He doesn't treat AI as assistants but as a team.

You can also copy this method.

Zevi has already published the process and the sources of errors. We have summarized it into a practical workflow: No matter whether you use ChatGPT, Claude, Doubao, or Zhipu Qingyan, if you are ready to let multiple AI systems work together, you can develop a product from scratch.

Section 1 | Starting Without Programming Knowledge: Find an AI That Challenges You

Zevi didn't start by writing the first line of code.

The first thing he did was to start a special conversation with an AI and tell it:

"You are my CTO. You're not allowed to just agree all the time."

This conversation stores all the information about the entire project. He assigned the AI a clear role: to make technical decisions, contradict him, and be responsible for the product quality.

This isn't using a tool but finding a partner who challenges him.

For people without technical knowledge, this is the real first step.

You don't have to learn programming but cooperate with AI. On what is this cooperation based? Not on technology but on skills you already have: clearly state what you want, set rules, and keep asking until your vague ideas become clear.

Zevi first chose Claude, not because it's the most powerful but because it's not superficial. He calls Claude "my ideal CTO": logical, fast, not afraid of questions, and never impatient.

This virtual CTO tells him:

• Why a function was designed wrongly;
• Points out gaps and dangers in a plan;
• Explains the logic behind technical decisions.

He doesn't have to understand what the AI has written. If he just explains to the AI why it wrote something, what it wants to achieve, and what the side - effects are, it's as if he has a teacher beside him who explains the entire product logic to him.

Don't you understand code?

Let the AI explain it to you, and then again. You don't have to be able to write but just ask. Slowly, code will no longer be terrifying but understandable.

So the first step isn't learning technology but opening a dialogue with an AI.

Zevi uses Claude Project, but this method isn't limited to a specific tool. The important thing is to find an AI that stores the project context, works according to your rules, and communicates well. To decide whether a tool is suitable, ask yourself three questions:

Can it permanently store the context?

Can you define the role and position of the AI?

Can you clearly express your ideas in natural language?

If the answer to all questions is yes, you've found the right one.

This is the start.

Section 2 | Not Using AI but Forming an AI Team

Opening a dialogue is just the beginning.

Zevi's next step is to turn a single AI into an AI team.

In Cursor, he assigned each model a clear task:

• Technical Leader Claude: Focuses on architecture, communicates well, and contradicts unreasonable plans.
• Bug - fix Expert Codex: Talks little and only fixes problems.
• Designer Gemini: Has creative ideas, writes code freely, and the resulting interfaces are impressive.
• Workspace Cursor: Enables these models to work together on a project.

He even defined the relationships between the AI systems. It's not that one follows the other but that they make suggestions to each other: After an AI has written code, he lets other AIs review it and then asks the first AI to check if the suggestions make sense.

Why this division?

Because each model has weaknesses. Claude communicates well, but its interfaces aren't as dynamic. Gemini has great designs, but the process is chaotic. Codex solves problems quickly but doesn't like to explain.

If you only use one of them, you'll either get stuck with its weaknesses or waste time fixing its flaws.

But if you know what each model is good at, you can assign it only the 20% of the work it does best instead of forcing it to do 100%.

Zevi designed this division with prompt words. He broke down the entire development process into reusable commands: From idea collection to code execution and post - review. Each step has a clear responsible party, and each step can be repeated.

The core of this process isn't that AI writes quickly but that they cooperate well.

If the first step was to communicate with AI, then this section is about getting multiple AI systems to work together towards a common goal.

Zevi uses a combination of different large models. You can assemble your own combination from the available tools. The core is to understand the strengths of each AI: Some are good at logical thinking, others at creative expression, and still others at debugging. Find their strengths and let them only do what they do best, and you can form your own team.

Section 3 | From Idea to Launch: The Birth of a Real Product

Zevi doesn't do demonstrations.

He actually developed a launched AI application: StudyMate, a learning tool that automatically generates test questions.

"The user uploads a PDF, and it analyzes the material, asks high - quality questions, and explains why the answer is right or wrong. Now this product can be used normally and generates revenue."

At first, he only wanted to make multiple - choice questions. Later, he found in a survey that the competition already offered fill - in - the - blank questions. So he decided to add this function immediately.

So this is how he went through the entire process:

1. A Simple Idea Becomes an AI - Executable Task

He verbally expressed a requirement: I want to add a fill - in - the - blank function, preferably with draggable options, two blanks, and six options.

The AI then asked:

How difficult should the fill - in - the - blank questions be? For beginners or advanced users?

Should the UI style continue the current minimalist design or be more interactive?

How many points are given for a correct answer? Should there be a time limit?

After a few rounds of conversation, the AI summarized the requirement into a structured task record: Function name, core requirement, technical points, open questions - everything is written down and can be directly used for development.

2. Don't Write Code First, Understand the Problem

After the task record is available, the next step isn't to start writing code directly but to let the AI scan the code base and analyze the scope of influence.

The AI created a technical evaluation report:

• Affected modules: Database, test engine, frontend interaction, prompt system
• Technical difficulties: The existing logic only supports multiple - choice questions, and the rules for fill - in - the - blank questions are completely different
• Potential risks: The drag function could conflict with the mobile version

In this step, no code was written, but all technical risks were identified.

3. Development, Review, Testing - All in One Go

Zevi let the AI convert the technical report into an execution plan and then distributed it to different AIs:

• Change the database structure → to an AI with backend knowledge
• Rewrite the test logic → also to a backend AI
• Implement the drag interaction → to an AI with frontend knowledge
• Full test → finally checked by a bug - check AI

After each AI has written its part, Zevi lets it be reviewed by other AIs: The writing AI reviews itself, other AIs look for errors from different perspectives, and then the first AI decides if the suggestions make sense.

He says:

"I don't want the AI to write perfectly but to know who can find the errors after it's written."

After all code reviews are passed, the testing phase begins. Zevi manually tests the core process and then lets the AI check the edge cases: What happens with empty answers? What happens if you want to cancel the drag? Are there any problems on mobile devices?

4. Launch and Post - review

After the test is passed, the function is launched.

It took less than a week from the idea to the launch. Now the fill - in - the - blank function is running in StudyMate, and real users are using it.

But Zevi doesn't stop there.

After the launch, he did something that many people forget: He lets the AI conduct a post - review of the entire development process.

1. Which step was misunderstood at the beginning?
2. Which prompt words could be written more clearly?
3. Can we be faster with similar requirements next time?

Then he updates the prompt words and the development documentation with these experiences. The next time a function is built, it will go more smoothly and quickly.

This is Zevi's complete path.

It's not a demo, not a proof of concept, but a real launched, user - used, and profitable product.

From the requirement to the launch, Zevi broke down the development process into verifiable small steps, assigned multiple AI systems clear tasks, and documented each step. This process can be copied, iterated, and continuously improved.

This is the complete process of how a non - technical PM develops a product from scratch.

Section 4 | Eight Commands, a Repeatable Workflow

The most valuable thing about Zevi isn't what product he developed but that he turned each step into a standard process that anyone can copy.

This isn't a method that can only inspire you but a practical tool list:

• Quick idea collection: Capture ideas, bugs, and feature requests without interrupting your current work. Tickets are automatically created.
• Discovery phase: Let the AI understand the requirements and find the key problems. Don't hesitate to write code but think through the problems first.
• Planning: Break down the task into executable steps and create a planning document with which you can track the progress.
• Execution: Strictly execute the steps without skipping steps or improvising freely.
• Self - review: Let the AI review its own code, look for bugs and risks, and not overlook any details.
• Peer review: Let multiple models review each other and find errors from different perspectives.
• Documentation: Record decisions and plans so that the AI can refer to them the next time a function is built.
• Learning opportunity: Let the AI explain unclear concepts and logics to you and turn problems into learning opportunities.

Zevi turned each step into fixed instructions. You don't have to remember every detail. Just tell the AI which step it should execute, and it knows what to do.

This workflow can be improved step by step. Start with a simple dialogue AI and understand the process in the chatbox. When you're familiar, add a programming tool and try the execution and review. If you want to go deeper, use different AIs for different modules. In the end, you can build an AI team that develops a product together.

You don't have to do everything at once. The key is to establish a repeatable workflow: Turn temporary decisions into reusable processes and turn vague ideas into clear steps.

So each step can be verified, each result can be reviewed, and each process can be improved.

It's not about learning a specific tool but shaping your own work style.

Start with a dialogue, start with a prompt word.

Conclusion | From "Can't" to "Can": All You Need is a Workflow

Zevi's story shows: The lack of programming knowledge isn't an obstacle to product development.

The key is to have a repeatable workflow.

From opening a dialogue to getting multiple AIs to cooperate and formulating commands - this method doesn't depend on talent and isn't limited to a specific tool. All you need is the willingness to start.

Zevi took a year to find this path.

Now this path is in front of you.

📮References:

https://www.youtube.com/watch?v=1em64iUFt3U&t=1s

https://