Agentic development with Mimo: how to distribute architecture, coding, and testing among AI models

Agentic development with Mimo is based on distributing roles among AI models. A powerful model designs the solution, Mimo 2.6 Pro handles routine tasks and writes code, and a separate model checks the result. This approach reduces the cost of iterations, but manual checking remains mandatory.

Mimo is suitable for prototypes, simple web applications, 3D scenes, and browser games.

A complex project cannot be handed over to it in a single general request without supervision.

Which tasks should not be delegated to Mimo without checking

The main limitation becomes apparent not when the first version is launched, but when requirements must be preserved across iterations. According to the test author's observations, Mimo 2.6 Pro sometimes misunderstands the initial description, loses context, and requires repeated attempts. The basic function may still work, while the state logic, physics, controls, or interface remain incorrect. If the project is changed several times, every subsequent request must be checked against the original requirements, the affected files, and the behavior of functions that are already working.

Projects with several interconnected subsystems require especially careful checking:

• games with physics, collisions, enemies, a camera, and victory conditions;
• 3D scenes with animation, collisions, object movement, and interaction;
• interfaces with windows, a file system, display modes, and state persistence;
• applications where changing one function can break a screen that is already working;
• projects with a large number of files, dependencies, and implicit requirements.

But what if the generated project opens and looks convincing? That still does not confirm that it is ready. A working screen may conceal inaccessible files, an inability to restore a window to its previous size, incorrect collision handling, or an unreachable part of the level.

Step 1. Delegate architecture design to a powerful model

A powerful model should begin not by writing the entire project, but by preparing a technical plan. It describes the file structure, main components, data flow, interfaces between modules, and readiness criteria. A person checks the plan before coding begins, since an architectural error will later affect several subsystems and require repeated changes.

It is useful to record the following in the architecture document:

• the purpose of the project and the minimum result for the first version;
• the technology stack and limitations of the runtime environment;
• a list of screens, objects, components, and user actions;
• application states and transitions between them;
• the data format, file-naming rules, and resource-loading order;
• test scenarios used to check each function;
• functions that are not yet included in the first iteration.

The readiness criterion should be observable. The wording “make a convenient window” is too vague. It is better to write: “the user opens the window, minimizes it, maximizes it, resizes it, and restores its original position without losing its contents.” This criterion is useful to both the implementer and the checking model, because it gives both sides the same expected result.

Step 2. Break the architecture into small tasks for Mimo

Mimo should receive not the entire project at once, but a sequence of limited tasks. Each task should have one result, clear boundaries for changes, and a way to verify it. The implementer first creates the skeleton, then adds individual functions, and saves a working state after each stage. This order is especially useful when the next function depends on the application's existing state or file structure.

1. Create the skeleton. The model adds the directory structure, entry point, basic layout, and minimal display scenario.
2. Implement one subsystem. For example, character controls, a notes window, or loading a file list.
3. Add a check. The prompt contains user actions and the expected result, not just a description of the appearance.
4. Modify existing code. Mimo receives a list of permitted files and a prohibition against unnecessary architectural restructuring.
5. Save the iteration. The log records the changed files, completed tests, and remaining defects.

This order limits the cost of errors. If the model breaks only the window subsystem, the problem is easier to find and roll back than in a project where the scene, styles, controls, and resource loading are all changed in a single request.

Step 3. Formulate prompts with context and a testable result

A good request for Mimo includes the project context, current status, a specific task, constraints, and acceptance criteria. The request “improve the game” sets no boundaries: the model may change the level design, character behavior, or file structure even though the problem was limited to collisions. The request should explain not only the desired change, but also which parts of the project must remain unchanged.

A practical request formula looks like this:

• Context: what already works and which files are responsible for the required function.
• Task: one change formulated through a user action.
• Constraints: what must not be changed, which libraries must not be added, and which interfaces must be preserved.
• Result: a list of changed files and a brief description of the modifications made.
• Verification: the sequence of actions after which the function is considered to be working.

For example, instead of a general request, one could write: “Fix the player's collision with the turtle. A jump from above should defeat the enemy, a side collision should reduce the player's health, and do not change any other level elements. After the fix, check both scenarios and list the changed files.” This formulation does not guarantee correct code, but it makes errors detectable: the checking model receives two specific scenarios and a constraint covering the other level elements.

Step 4. Check the result with a separate model

The review should be performed by another model that did not participate in the latest change. Its task is not to evaluate the appearance, but to find discrepancies between the requirements and the project's behavior. A separate role reduces the risk of the same model confirming its own erroneous solution. The reviewer should work with the original requirements, the change log, and user scenarios, rather than only with a brief description of the latest request.

Functionality check

The reviewer goes through the user scenarios step by step and records the actual result. For a web application, they check opening screens, forms, search, data saving, and handling of empty values. For a game, they check controls, collisions, victory, defeat, the camera, and transitions between levels.

State error checking

The project's state is checked after unusual actions: reopening a window, pressing buttons rapidly, changing the screen size, going back, restarting a scene, and attempting to open a missing resource. Defects that are not visible during a sequential “by-the-script” demonstration often appear precisely during such transitions. If a function works only after a strictly defined sequence of actions, the check should reveal this limitation.

Interface and file checking

In the author's tests, the operating system interface contained an application search, notes, a calculator, weather, a stopwatch, Paint, and games, but some images, music, PDF, and text files could not be opened. In addition, some windows could not be minimized after being maximized, and restoring the size after stretching across the full width did not always work. These observations relate to the specific test project, not to every result produced by Mimo.

Step 5. Return a specific list of defects to the implementer

After the review, Mimo receives not a general request for improvement, but a list of defects with reproduction conditions. Each entry should answer four questions: what the user did, what happened, what was expected, and where to look for the cause. When the cause has not yet been established, it is sufficient for the entry to record the observed behavior and the constraint against changing other parts of the project.

If there are many defects, they are sorted by impact: first blocking errors, then violations of the core logic, followed by interface shortcomings and visual details. Fixing a polygonal cherry in a 3D scene should not take precedence over restoring controls or correct collisions.

How to keep a log of iterations, time, and cost

The log is needed not only to control expenses. It shows how many repeated requests a particular function required and where the low price of a single generation stops producing savings. For each iteration, record the test date, task, model, duration, estimated cost, changed files, errors found, and the acceptance decision. Such records make it possible to separate the cost of the initial generation from the cost of fixes and repeated verification.

In the provided materials, the author reported the following results from their own tests: the initial generation of the 3D aquarium took 5 minutes 31 second, while its refinement increased the project's total cost to 7 cents and took 6 minutes 52 seconds. According to the author's estimate, the operating system interface took 16 minutes 43 seconds to create and cost about 5 cents. A browser game in the style of Super Mario required about 16 cents, and creating the project took 27 minutes. These are data from a specific experiment, not universal Mimo rates.

What should be compared is not the price of the first response, but the cost of an accepted result. If an inexpensive generation requires numerous repetitions, manual searches for regressions, and architectural rewrites, its price advantage disappears.

When Mimo's savings stop working

Mimo is rational to use for small tasks where the result is easy to check and an error can be isolated. The author assessed projects with 3D ice cream, an aquarium, and an operating system interface as suitable for further refinement, although they still contained problems with details, physics, animation, files, and windows.

A complex project requires a different distribution of roles when the requirements are interconnected, the context grows quickly, and an error in one module affects the others. In that case, a powerful model designs the architecture and helps analyze ambiguous decisions, Mimo writes repeatable fragments, and an independent reviewer checks the behavior after each significant change. A person compares the result with the project's goal and decides whether the fixes are sufficient for the next iteration or whether the architectural plan needs to be reconsidered.

A practical model-selection framework

Advertising benchmarks do not replace this kind of checking. According to the author's assessment, Mimo was inferior to Claude Opus, GPT Soul, and Fable 5 on complex tasks, although some comparisons placed it alongside Qwen, Grok, and other models. These results depend on the test set and do not confirm the same quality in all scenarios.

The Ultra Speed mode also cannot be considered demonstrably useful for the process described: the author did not see a clear practical use case for it in the tests presented. Its use should be evaluated in a separate experiment with predefined metrics, rather than added to the workflow solely because of its name.

A Final Agent-Based Development Workflow with Mimo

First, a powerful model turns the idea into an architecture and a set of verifiable requirements. Mimo then handles small tasks, preserving the working project after each iteration. A separate model reproduces the scenarios, looks for hidden errors, and compiles a list of defects. A human decides whether to publish.

This process does not make Mimo a replacement for a lead developer. It takes advantage of Mimo’s strengths, the affordable cost of repeated generations, and its ability to quickly assemble simple prototypes, while moving architectural decisions and quality control beyond the scope of a single model.

Frequently Asked Questions

Can Mimo be assigned the entire project in a single request?

For a small prototype, such a launch is possible, but the result should be treated as a draft version. In complex development, a single broad request increases the risk of lost requirements, unnecessary changes, and regressions that are difficult to detect.

Is Mimo suitable for games and 3D scenes?

According to the author's observations from the tests, Mimo creates acceptable basic 3D scenes and browser games. They may still contain issues with physics, controls, the camera, animation, and level logic, so testing should cover not only the appearance but also the execution of scenarios.

Which matters more: low generation cost or the quality of the first attempt?

For a simple prototype, a low cost makes it easier to iterate quickly. For a complex project, the cost of the accepted result matters more, including repeated generations, reviews, fixes, and developer time.