How to Use Verdant's Free Coding Mode to Fix a Real Bug
A step-by-step guide to Verdant's free coding mode, showing setup, prompt structure, and a real JavaScript bug fix from start to test verification.
What is Verdant’s free coding mode?
Verdant is an AI coding tool where you open a project, describe what you want changed, and let an agent read files, make edits, and run commands to check its own work. Free mode is a way to use that agent without a subscription or credit purchase. It runs on what Verdant describes as basic models suited to light work, refreshes on a recurring allowance, and also carries a weekly cap. For anyone who wants to test an AI coding agent before committing to a paid plan, it’s a low-risk way to see whether the workflow fits how you build.
TL;DR
- Verdant’s free mode lets you run coding tasks in the desktop app with no subscription and no credit spend, sitting alongside the paid Eco and Prime modes.
- Usage is governed by a short refresh window (every 5 hours, per Verdant) plus a separate weekly cap, so heavy or repeated sessions can still hit a ceiling.
- A practical test on a small JavaScript shopping cart bug showed the agent could reproduce a failing test suite, apply a minimal fix, and rerun tests to confirm the result, all inside one request.
- The best prompts for free mode spell out the problem, the expected output, and a way to verify it (existing tests, expected totals, or a clear before/after state).
- Free mode currently works through the regular project and new task flow; the separate task manager interface supports Eco and Prime but not free mode.
- Good starting tasks for free mode include small bug fixes, tracing unfamiliar code, minor UI text changes, and writing basic documentation, since each has an easy way to check the result.
- If you’re already paying for a subscription, Eco is a zero-credit alternative with its own quota, while Prime spends credits for access to stronger models when a task needs more capability than free or Eco can deliver.
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
How do you set up a task in Verdant’s free mode?
Setup follows a short sequence. Download Verdant from its official site, install the desktop app, and sign in. From there:
- Go to Projects and click New Task.
- Select an existing project folder or create a new one. Using an existing folder makes sense if you already have code and tests prepared.
- Next to the message box, open the mode selector and choose Free.
- Type the request and send it.
One detail worth noting: free mode is currently tied to the regular project/new task flow, not the separate task manager interface, which supports Eco and Prime. If you’re specifically trying free mode, start from Projects, not the task manager.
What does a real free-mode coding test look like?
The demonstrated test used a small JavaScript function meant to calculate a shopping cart total by multiplying item prices by quantities. The function had two bugs. First, prices and quantities coming from a form could arrive as text strings instead of numbers, and adding strings in JavaScript concatenates them instead of summing them. Second, the function ignored quantity entirely, so buying multiple units of an item didn’t produce the correct total.
Five tests were prepared in advance covering string inputs, multiple items, plain numeric values, decimal calculations, and an empty cart. Before any fix, four of the five failed. Only the empty cart test passed, since the function started from zero with nothing to add.
The prompt given to the agent specified:
- Fix the cart total calculation.
- Note that prices and quantities may arrive as strings.
- Return a number rounded to cents, and return zero for an empty cart.
- Run the existing tests first, make the smallest fix possible, then run them again.
- Leave the test file unchanged.
- Stay inside the project and avoid adding dependencies.
This structure gives the agent three things at once: the problem, the expected behavior, and a way to check the outcome. That combination matters more in free mode than trial and error, since usage is capped.
How did the agent handle the fix?
The agent explored the project files, ran the existing tests, and confirmed the same failure pattern (four of five failing). It then edited the function, converting price and quantity values into numbers before multiplying them, summing the results, and rounding the final total to cents. After the edit, all five tests passed. Rerunning the tests separately, outside the agent’s own run, produced the same result: five passed, zero failed.
The actual code change was small, about two lines inside the function, and the test file was left untouched, which matters because the fix was being checked against the original expectations rather than a rewritten test suite. For a concrete example, two items at $12.50 plus one item at $5.25 correctly produced $30.25, matching the expected total.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
This was a small, prepared example rather than a stress test on a large codebase. It shows the mode can handle a scoped bug with a clear success condition. Larger or more ambiguous tasks would need separate testing before drawing conclusions about performance at scale.
How is free mode different from Eco and Prime?
Verdant’s update introduced a simplified choice between three modes rather than picking specific model names for each task:
- Free: available without any subscription, running on basic models suited to lighter work, subject to a refreshing allowance and a weekly cap.
- Eco: costs zero credits but requires an active subscription, with its own separate quota.
- Prime: spends credits to access stronger models, intended for tasks that need more capability than free or Eco can provide.
The practical decision point is usage and task difficulty. If you don’t have a subscription, free is the only option. If you do subscribe, Eco is worth trying before spending credits on Prime. The signal to move up a tier is the quality of results: if a focused task keeps coming back incomplete, or you’re spending several attempts correcting the same misunderstanding, that’s a reason to reconsider the mode, not just the prompt.
What are the limits of the free allowance?
Verdant states that free mode refreshes every 5 hours and also enforces a weekly cap, so the shorter refresh doesn’t override the longer-term limit. No fixed number of messages or tasks per period is published, so the practical approach is to check usage information inside the app before starting anything that might require multiple rounds of edits. This makes it worth front-loading context into the first request (the error, the expected result, and any tests) rather than relying on several exploratory follow-ups.
What kinds of tasks suit free mode best?
Beyond bug fixes with existing tests, a few other task types fit the free tier well because each has a clear, checkable outcome:
- Understanding unfamiliar code: asking the agent to trace a specific flow (like where a form submission goes) and explain the relevant files before anything is changed.
- Small, clearly worded interface changes: fixing a confusing button label or an empty state message, then checking the result visually rather than relying only on a test pass.
- Basic documentation: asking the agent to explain how to run a feature and its tests, then following those instructions yourself to confirm they actually work for someone unfamiliar with the project.
The common thread across all of these is deciding, before sending the request, exactly how you’ll verify the result. That’s what turned the cart calculation test into a clean pass/fail rather than a subjective judgment call.
Frequently Asked Questions
Does Verdant’s free mode require a subscription?
No. Free mode is available without a subscription or credit purchase. It’s distinct from Eco, which also costs zero credits but does require an active subscription.
What are the usage limits on free mode?
Verdant describes a refreshing allowance every 5 hours plus a separate weekly cap. No specific message count is published, so usage should be checked directly in the app, especially before starting a task likely to need multiple rounds of changes.
Can free mode handle real bug fixes, not just simple demos?
The tested example, a JavaScript cart calculation bug involving string inputs and ignored quantities, was fixed correctly: the agent reproduced the failing tests, applied a two-line fix, and reran tests to confirm all five passed. It’s a small, scoped example, so larger or more complex projects would need their own testing.
How is free mode different from Eco and Prime in practice?
Free needs no subscription and runs on basic models for lighter work. Eco needs a subscription but costs zero credits, with its own quota. Prime spends credits for stronger models, useful when a task exceeds what free or Eco can reliably handle.
What’s the best way to prompt Verdant in free mode?
Include the problem, the expected outcome, and a way to verify it, such as existing tests, expected numeric results, or a clear description of correct behavior. This reduces back-and-forth, which matters given free mode’s usage caps.
