Manus and AI agents are changing development: MVP code now appears in 20 minutes

AI-agents have reached that part of development where days used to disappear: project startup, frontend-backend integration, rough architecture and the first working demo screen. In an article on Habr AI, the author tested this with Manus and showed how a startup idea turns into working code in about 20 minutes.

Why code got faster

Programming turned out to be one of the most suitable environments for generative models. Programming languages have strict syntax, repeating patterns, and a clear result format: either the code compiles and does what's needed, or it doesn't. That's why LLMs have already taken over a large chunk of routine work — from finding examples and writing boilerplate to SQL queries, indexes, API wiring, and fixes between frontend and backend. Where a developer used to spend hours on documentation, forums, and stitching pieces together, now the first draft appears almost instantly.

But an ordinary chatbot quickly hits a ceiling. The more complex the task, the more copy-paste, manual synchronization, and fighting with context loss. The same person has to keep re-explaining to the model what endpoints already exist on the backend, how the frontend component is structured, and what exactly broke after the last fix. As a result, there is acceleration, but it runs into mechanical management: you're no longer writing code so much as transferring context between windows and messages.

Experiment with Manus

Against this backdrop, the author took Manus — an agentic tool that doesn't just respond in chat, but breaks down the task into a sequence of actions and runs many steps through the model in a row. Instead of scattered fragments, it should return a more cohesive result: product concept, project structure, ready-made files, and a working demo. To test this, the author gave it a startup idea and asked it to assemble an MVP from near scratch.

According to his description, generation took about 20 minutes and cost a few hundred rubles. The output was not just a set of files, but a tangible product draft that can be downloaded, opened in an IDE, refined, and shown to others. Most important for the author was that the agent returned not snippets of logic, but a connected framework that can be worked with like a normal MVP, rather than as a pile of chat suggestions.

• Thoughtful MVP concept without a blank sheet
• Backend and frontend linked into one system
• Demo version that you can click through right away
• Ability to ask questions about the generated code

"It's not 100% finished — but it works."

The main effect here is not magic, but compression of time. What used to take days of startup assembly, basic architecture, and manual integration, the agent packs into one long run. For a solo founder or small team, this lowers the entry price for an MVP: there's a chance to test the idea faster without starting from an empty repository and an endless list of small technical tasks. This changes the rhythm of first launches and allows you to show the concept to partners, first users, or investors faster.

Where the agent hits its limits

At the same time, the author doesn't conclude that developers are no longer needed. On the contrary: the more experienced an engineer or startup founder, the more noticeable the limitations of this approach. The agent does well at filling a blank sheet, but struggles to feel product priorities, trade-offs, and long-term consequences of decisions.

It can assemble a working foundation, but doesn't truly understand where to lay a strong core, where to cut corners for speed, and where technical debt will hit the entire project later. There's also a second problem — the illusion of productivity. When a tool generates the interface, server-side, and demo on its own, it seems like the product is almost ready.

But then comes the most expensive phase: deciphering someone else's logic, reviewing architecture, checking bottlenecks, security, maintenance, and development. If a person didn't control the system during assembly, they'll pay later — with time spent understanding how this code even lives and what will break first.

What this means

AI-agents like Manus are already making draft software creation noticeably cheaper and faster, but this is still not a replacement for strong developers, but an amplifier for those who know how to set a task and make engineering decisions. The market is shifting from manual code writing to the ability to formulate requirements, check results, see architectural risks, and take responsibility for the system after the initial wow-effect of generation wears off and ordinary engineering work begins.