«Vibe Coding» FAQ

Among the verified names, the leader is Claude; followed by Codex and Gemini. Here is the number of messages containing the name or a variant spelling:

Data: 7 HTML files, 5,709 text messages from August 6, 2025 — October 17, 2026. After excluding bots and forwarded posts — 5,554. Search by names and spelling variants; each tool is counted once per message. Claude combines mentions of models, chat, and Claude Code; for ChatGPT, the separate word GPT was not counted. One reply may contain several tools. This is mention frequency, not the number of users, paid subscriptions, or quality assessment.

GLM / Z.ai, DeepSeek, n8n, OpenCode, Qwen, Lovable, and Perplexity were also mentioned. A low number of mentions does not prove a tool is inferior.

Claude Sonnet — our starting option for routine edits, implementing straightforward tasks, and quick iterations. Anthropic positions this line as a balance of speed and quality.

Claude Opus — a candidate for long-running agent work, complex changes, and tasks where the simpler option requires too many rework cycles. Claude Fable the manufacturer recommends this for the most demanding reasoning and long agent tasks, if Opus results are not yet meeting requirements.

Claude Haiku — a candidate for mass classification, field extraction, and request routing in a bot. Test the quality on your own examples; it's better to verify complex architecture separately with a stronger model.

This is a breakdown based on positioning of Anthropic's current product lines, not the result of our benchmark. Available versions and terms may vary between API, subscription, and the editor.

In Codex or another agent: start with the recommended model for your interface. Increase the reasoning level for tasks with many dependencies when quality is lacking; for minor edits, compare it with the faster mode. Evaluate the cost of a finished, verified solution, including fixes.

1. A beginner building their first service: Lovable → one main scenario → input and access verification. Add a repository agent when a specific need arises.
2. You have a project and a complex bug: Cursor, Codex, or Claude Code → reproduction → cause → minimal fix → verification of old and new behavior. You can involve another model for an independent review, but ask for specific proof for every observation.
3. You need an inexpensive Telegram digest: n8n → sources → deduplication → model for summary → draft for review. Compare price and errors on the same selection of news before automatic publication.

Prompt — your message containing a task for the AI. Code — instructions for the computer. Agent — an AI with tools that can, for example, read and modify files and run checks within the provided access.

After launching, change one condition yourself—for example, the number of stars. Ask it to explain why that specific change works: this way, you will verify its understanding.

What: 2D arcade, puzzle, or reaction trainer.

With what: Codex / Claude Code / Cursor; for a quick prototype — Canvas. Start with simple HTML/JS or the first 2D scene in Godot.

First version: One mechanic, win/loss, restart, and mobile controls. Add multiplayer only after you have a working single-player game.

How it can earn: Branded mini-game by commission or a paid full version. Advertising requires an audience.

First project in Godot ↗

What: Application → table → reminder; order status; digest.

With what: n8n for connecting services; Codex or Claude Code for custom logic.

First version: One scenario, a test chat, protection against duplicates, and a clear error message. For automated posts, check drafts first.

How it can earn: Charge for setup and separately for support. Agree on who pays for hosting and APIs.

n8n Documentation ↗

What: Remove clutter from a page, copy selected fields, or export a table.

With what: Codex / Claude Code / Cursor + Chrome Extensions documentation.

First version: One button for one task; local processing, minimal permissions. Test on several pages with different data.

How it can earn: License, additional paid feature, or an extension tailored to a specific team's workflow.

First Chrome extension ↗

What: Batch renaming, scene checking, exporting selected models, or a small toolbar.

With what: Codex or Claude Code for Python; provide the exact software version and a small test scene.

First version: One repeatable operation on a scene copy, a preview of changes, and an undo option. Rigs and skins require separate testing.

How it can earn: Selling a useful script or a setup tailored to a studio's pipeline. Knowing how a 3D professional works will help you choose the right function.

API Maya ↗

What: Image sorting, renaming, CSV cleaning, or subtitle preparation.

With what: Codex / Claude Code; start with a simple script, then a window with buttons.

First version: Test folder, preview list of changes, copy of the result in a new folder. Check for empty files and duplicate names.

How it can earn: One-time commission or a license. Installation, updates, and support are part of the product.

Desktop product example ↗

What: Merge several CSVs, find discrepancies in a catalog, search for CRM records from one team.

With what: ChatGPT for data research; Codex / Claude Code or n8n for re-running.

First version: A small set of known examples and verifying the results. Read-only at first; enable record modification only after verification.

How it can earn: Setting up reporting or integrations for business. Sell the specific amount of manual labor saved.

Raycast ↗ integration example

What: Timer, progress bar, break screen, or event scoreboard.

With what: Codex / Claude Code / Cursor for HTML/CSS/JS.

First version: One screen, clear settings, check at actual stream resolution. Start without a server.

How it can earn: Custom design or themed set. We have a free example to view; we do not claim sales for this example.

Our OBS overlays ↗

Hasaam Bhatti in an interview from June 2, 2026 describes an MVP in Cursor in 48 hours and $30k MRR at the time of the conversation — monthly recurring revenue, not net profit. This is the founder's statement. The tool helps research products; the first customers came through a partnership with an Amazon sellers' learning community.

Takeaways: the author knew the problem from their job and found a channel to buyers. They built the prototype quickly; development and customer acquisition took months. Before building a big product, show one useful feature to people in your profession.

Founder interview ↗

Pieter Levels created an AI browser flight simulator. The game page indicates Cursor + Three.js and offers paid planes and in-game advertising. These are visible ways to monetize; their presence alone does not confirm sales volume.

Takeaways: start with a mechanic that is fun to play just a minute after opening. First, test the controls and the desire to play again, then the shop. Public promotion and the author's audience are part of the success story, not a property of Cursor.

The game itself ↗ · Author's story ↗

Mac developer Indragie Karunaratne July 1, 2025 described a released SwiftUI app, almost entirely written with Claude Code. The agent also helped with build and release automation. The author emphasizes requirements, iterations, and testing. There is no confirmed income in this case.

Takeaways: a small professional tool can be more valuable than another generic service. A pro defines the right behavior and assesses quality; AI helps with implementation and delivery routine.

Author's breakdown ↗

Paul Minors May 5, 2026 showed Pipedrive contact and deal search directly from Raycast. According to the author, working with Claude Code took about an hour; the first version had to be fixed. This is an example of custom automation, with no reported revenue.

Takeaways: combine two tools you constantly switch between. Start with searching via the official API and pre-describe which fields and results are needed.

Author's demonstration and description ↗

How it works. Minions get a separate prepared environment. AI implements the task and fixes errors; running linters and submitting changes are performed via standard software steps. After local checks — CI, one attempt to fix its errors, then human review.

Result. In a publication from February 19, 2026, Stripe reports over 1,300 merged PRs per week, fully written by agents and verified by humans. This is the volume of accepted changes, not the measured acceleration of every developer.

What to repeat. Move repetitive checks into commands, give the agent a ready environment, and limit the number of fruitless attempts. Original Stripe description ↗

How it works. The team found dependent repositories via Backstage, and Honk prepared changes under Fleetshift management. General instructions proved insufficient: precise mapping tables for old and new fields and explicit exceptions were required.

Result. In a case from April 22, 2026 — 240 prepared automated PRs and approximately 10 engineering weeks of saved labor according to the team's estimate. This is not an independent experiment. Automation of heterogeneous Scio projects was postponed; for SQL repositories without proper pre-merge tests, the results were checked manually.

What to repeat. For mass replacement of an API or data schema, first prepare 'was → became' rules and a list of cases for a human. Original Spotify description ↗

How it works. Engineers use Claude Code for tests, API mocks, components, fixes, and documentation; they run separate sessions in parallel and apply AI for reviews.

Result. Rakuten reports a reduction in average time-to-market for new features from 24 working days to 5. This is a client case on the Anthropic website: a reported result of specific teams, without an independent control group. It does not guarantee the same acceleration on another project.

What to repeat. While you make a technical decision, the agent can separately explore the code or prepare tests. Parallel changes require agreed-upon boundaries and verification after merging. Rakuten / Anthropic Case Study ↗

A bug in an existing product. Give the agent reproduction steps and a log. For a logic error, ask for a failing test on the old version first, then the fix. Verify that the test catches exactly the bug and that adjacent scenarios still work.

A repetitive API migration. Create a 'old call → new call' table and note exceptions. Test on 2–3 typical modules, review the result, and only then expand. If the change is mechanical, a reliable replacement script might be simpler than repeated AI prompts.

A game or tool for Maya/Blender. Provide the software version, a test scene, and one goal: jump mechanics, batch export, or name verification. The agent prepares the code; you run it in the engine or 3D software, checking controls, results, and speed on a real scene. First a scene copy, then integration. This is our adaptation for game dev and 3D, not a specific studio's internal process.

Compare similar tasks by time to an accepted change, including setup, review, fixes, and waiting for checks. Add model costs and the number of post-release errors. The number of lines of code, agents, or PRs alone does not show value.

First, test the process on a few limited tasks. If rework takes more time, try a smaller task, better examples, or simpler automation. For a product with an embedded model, maintain a set of real examples with expected results and verify it after changing the prompt or model.

Editorial selection based on capabilities verified on October 18, 2026. This is not a ranking based on a single test: quality depends on the model, project, and available checks.

• Codex Cloud — delegate a feature or a fix to a repository. Each task has its own workspace; work can continue while your PC is asleep. You can review changes and check results, resume a task, and open a pull request — a proposal for changes to be reviewed. Documentation ↗
• Claude Code — bugs, refactoring, and evolving an existing project. There are local and cloud sessions. The cloud session continues running after you close your laptop; Remote Control only provides access to a local session from another device. Cloud mode and differences ↗
• Cursor Cloud Agents — delegation with application verification. Separate cloud machines can build the project, run tests, and work with a browser. There are parallel tasks, MCP, and multi-repository environments. You need to configure project startup and monitor costs. Capabilities and pricing ↗
• GitHub Copilot cloud agent — small task → PR in GitHub. Convenient for limited fixes and tests. Per documentation: one repository, one branch, and one PR per task; maximum session time is 59 minutes. Large tasks should be split up. Limitations ↗
• Devin — cloud tasks and repetitive procedures. Scheduled Sessions starts work on a schedule; a playbook describes repetitive steps. For example, you can set up preparation for fixing broken tests. This is an example of application, not a promise to automatically maintain an entire product. Scheduled runs ↗
• Gemini CLI — an agent in the terminal and part of your own script. Headless mode executes a request without dialogue and can return JSON. It is suitable for analyzing logs, code changes, and automations. For repeated runs, a separate schedule or process is required. Headless mode ↗
• OpenHands / OpenCode — more control over your own configuration. OpenHands has an SDK for programmatic agents; OpenCode can be connected to Ollama. Running a local shell does not necessarily mean using a local model. OpenHands SDK ↗ · OpenCode + Ollama ↗

Our practical choice: start with Codex or Claude Code for your repository; Cursor — if working in the editor and cloud delegation is important; Copilot — if your entire process is already in GitHub. For a fully local experiment — see the instructions below. Before paying, give two candidates one small task in separate project copies and compare the result, time to fix, and costs.

Yes, in the appropriate environment, but "autonomous" does not mean "without limits and guaranteed to finish." A session can be stopped by quotas, timeouts, lack of access, a request for human intervention, or an error loop.

Real example: OpenAI described an experiment in which Codex spent approximately 25 hours creating a design tool, using about 13 million tokens. This is a demonstration with prepared requirements and checks, not a promise for any task or plan. Experiment description ↗

What to prepare: a working run, required dependencies, a verifiable result, small stages, a progress file, and a time/cost limit. After a repetitive identical error, the agent should flag a blocker. Leave merging into the main branch and product release as separate controlled steps.

Set the budget limit also in the service settings or program: text in the prompt is not a reliable financial constraint. More production examples in the section about Stripe, Spotify, and Rakuten.

MCP — a standard for connecting tools and data. Skill — instructions and resources for a specific task. Sub-agent — a separate executor of a part of a task. SDD — working from described requirements and readiness criteria. Harness — an environment that organizes the work of the model and its tools.

Add them under a specific problem. A set of dozens of skills does not prove quality and can increase complexity and costs.

Examples from chat questions:

• Telegram news: first define sources, schedule, and duplicate filtering. An autonomous agent is not necessarily required for this. AI can be used only for short summaries; start with drafts for review.
• Sales bot: a natural style won't fix made-up prices. You need an up-to-date catalog, response verification, and handing complex cases to a human. MCP is a possible connection method, not a mandatory requirement.
• Multiple agents: define a task, available data, and the required output for each. Project memory, agent coordination, and your product's API are separate issues; do not mix them.

Start with the simplest scheme that executes the required scenario and that you can verify.

1. One role: for example, checking a product table. Input is CSV; output is a report with row numbers.
2. Ready-made model: cloud API or a local model. Chat and API subscriptions may be paid separately.
3. Minimal tools: read a test file, check fields, write a report to a separate folder. Do not give access to the entire disk immediately.
4. Cycle: received task → chose action → executed tool → read result → continued or finished.
5. Check: give it a few files with known errors and one correct one. Check if the agent finds what is needed and doesn't hallucinate problems.
6. Only then automation: add scheduled runs, result history, attempt limits, and failure notifications.

Ask a coding agent to assemble such a first version. If all rules can be precisely written in regular code, start with a script: it can be cheaper and more predictable than an agent.

• OpenAI Agents API: a managed Codex harness for long-running tasks with session persistence. Agents SDK: a loop and custom tools within your application, with greater control over deployment. These are different ways of organizing an agent. API vs SDK Comparison ↗
• Claude Agent SDK: embed the Claude Code agent loop into Python/TypeScript with file tools, sessions, permissions, and hooks. For third-party products, use the API authentication specified in the documentation. Documentation ↗
• LangGraph: when custom transitions between steps, state saving, and recovery are needed. A Checkpointer saves the progress of a specific task; a store saves data between sessions. For restarts, persistent storage is required: InMemorySaver disappears along with the process. Memory and recovery ↗
• OpenHands SDK: an open-source toolkit for software agents with a terminal, file editing, and a custom workspace. Code and examples ↗

Practical framework: task queue → isolated executor → permitted tools → saved progress → result verification → review. Before repeating an operation, check if it has already been executed: a restart should not create a second order or send an email twice. Measure accepted results and task costs, rather than the number of agent steps.

1. Install LM Studio from the official website.
2. Find a model in Discover. For a first small test, consider Qwen 3.5 4B in a 4-bit version; this is our starting suggestion, not a ranking of the strongest models. The Q4 designation means a compressed representation of weights with a trade-off between memory and quality.
3. Download the model, open Chat, select it, and load it into memory. Ask it to explain a short code snippet or summarize a test document.
4. After the initial download, you can disconnect the internet and test the local chat. Web search and remote tools will not work offline.

LM Studio supports local chat, document processing, and a local server without internet after the necessary files are downloaded. What exactly works offline ↗ · Qwen 3.5 variants ↗.

RAM — PC RAM; VRAM — video card memory (VRAM). Both are important. For Windows, LM Studio recommends at least 16 GB RAM and 4 GB of dedicated VRAM; this is a guideline for the application, not a guarantee that any model will run. Official requirements ↗

Start with a small 2–4B model and a short context for chat. If you have memory to spare, compare it with a larger version, such as 9B. B stands for billions of parameters. The file size does not equal the required memory: additional context and service buffers are needed.

For a coding agent, requirements are higher: it passes instructions, code, and tool results to the model. Ollama recommends a context of at least 64k tokens for such tasks; increasing context requires more memory. Do not set the maximum arbitrarily. Context explanation ↗

In LM Studio, you can pre-estimate memory with the command lms load --estimate-only <model_key>. In Ollama, the command ollama ps shows context and the CPU/GPU distribution. If everything is slow, first check the memory and task size; do not buy a new video card just based on a benchmark promise. Memory estimation ↗

This is the next step after local chat. First, install the latest Ollama and OpenCode following the official integration instructions. Prepare a copy of a small project or a separate Git branch.

1. Download a local model with tool support. For a trial: ollama pull qwen3.5:4b. Do not choose the cloud option if local computation is required. Model card ↗
2. Set the context to 64k: the Ollama integration specifies this requirement for OpenCode. Check if you have enough memory; a small model doesn't eliminate the costs of a long context.
3. In the terminal, open the test project folder and run ollama launch opencode. In the provider/model selection, check specifically for Ollama and the downloaded local model.
4. First task: "Read the project and explain how to run it, but don't change anything yet." Second task: one small fix with a specific check. Review the changed files and run the result.

An alternative is Codex CLI with Ollama via ollama launch codex. This is a Codex shell with a selected local model, not an OpenAI cloud model downloaded to your PC. Integration setup ↗.

This is a diagram based on documentation, not a measurement of your PC. A local model may perform poorly on complex multi-step tasks; start small and verify actual actions, not just convincing answers.

Useful first tasks: explaining your own code, drafting documentation, searching local texts, classifying files, and preparing small scripts. For Maya/Blender, the model can prepare code, but scene verification requires an available tool and running it within the program itself.

For fully local execution, there is no payment to a cloud provider per token, but there are costs for hardware, electricity, and setup. Check the specific model's license before commercial use. Web search, remote MCP servers, or a cloud provider may transmit data externally, even when the agent window is open on your PC.

To get advice in the chat, write: OS, RAM amount, exact GPU and VRAM, the task, and whether a total absence of internet is required. You won't get a reliable model selection based on just the name "gaming laptop."