OpenCode Go, DeepSeek V4 Flash, and the moment Codex became optional

There is an old kind of proverb that says a worker may sharpen the blade all morning, but if the blade is poor, the tree still stands at sunset.

https://opencode.ai/go?ref=F31TPWD40H

For many weeks, the Director sharpened tools that would not cut cleanly.

Some tools promise much.

Some change shape in the hand.
Some require payment yet return confusion.
Some speak confidently, but do not look at the work before them.

The worker sharpens the blade.
The tree remains standing.

Then, on the twelfth day of June, as a birthday gift not wrapped by man but found in the working of the day, another tool was placed into the hand.

OpenCode Go.

And with it came DeepSeek V4 Flash.

The blade bit.
The work moved.

The tangled branches of product feeds, variations, database rows, product pages, colours, sizes, prices, stock, and outlinks began to separate into order.

One product was no longer fifteen products.
One page became one page.
One variation became one chosen thing.

The catalogue began to speak more truthfully.

So this Tech Scroll is not merely an advert.

It is a witness from the workshop.

When a tool is good, the worker knows. And when a good tool arrives on the Director’s birthday, it should not be hidden in the drawer. It should be shown to others.

OpenCode Go has been tried on real work, and it has been found worthy of attention.

Use this referral link and both sides receive $5 usage credit when you subscribe to Go:

https://opencode.ai/go?ref=F31TPWD40H

In the United Kingdom, the first month came through at about £3.88 before processing fees. Outside the United Kingdom, OpenCode Go is listed at $5 for the first month.

This was not a toy test

There are moments in technology when something quietly changes in front of you.

Not with a grand announcement.
Not with a glossy sales page.
Not with a keynote.

Just one working session where the tool does what you needed it to do, properly, repeatedly, and without turning the whole job into a fight.

That happened here with OpenCode.

After weeks of frustration with changing AI coding tools, account behaviour, model changes, usage limits, and paid tools that were becoming harder to rely on for serious project work, there came a point where another route had to be tested.

So OpenCode was installed, connected, and given a real job.

Not “make a todo app.”
Not a benchmark prompt.
Not a neat little artificial task.

A real production migration task on AZ2.co.uk: PHP server-side rendering, database-backed product grouping, variation handling, merchant product feeds, malformed product names, category counts, selector logic, product outlinks, and the kind of messy live-commerce data that exposes whether an AI coding agent is genuinely useful or merely good at sounding useful.

And then DeepSeek V4 Flash through OpenCode Go just got on with it.

The problem it helped solve

The task involved product feeds where one real product could appear as many rows.

A bra with multiple colours and sizes.
A perfume with three bottle sizes.
A shoe with seventeen sizes.

A product catalogue where the database might say there are hundreds of rows, but the shopper should only see one product with selectable variations.

That matters.

A shop page should not show fifteen copies of the same shoe just because the feed contains fifteen sizes. It should show one shoe, with fifteen variations.

That is the difference between raw feed data and a real shopping experience.

OpenCode, using DeepSeek V4 Flash, helped move the site closer to that truth.

It found patterns.
It used the database.
It checked real pages.
It reasoned through the product structure.
It helped separate products from variations.
It helped reduce large duplicate-looking product counts into cleaner product families.

It worked with real PHP, real SQL, real URLs, real pages, and real product outlinks.

That is the kind of work where many AI coding tools start confidently inventing things.

This did not feel like that.

The “wow” moment

The moment was not just that it wrote code.

The moment was that it understood the shape of the problem.

A product is not always one database row.
A variation is not always colour and size.

Sometimes there is colour only.
Sometimes size only.
Sometimes capacity.
Sometimes no useful variation at all.

Sometimes the feed has American spelling.
Sometimes the site needs British English.
Sometimes a merchant name and brand name are not the same thing.
Sometimes an outlink must follow the selected raw product row, not the grouped parent product.

This is where OpenCode with DeepSeek V4 Flash became genuinely impressive.

It was not just producing patches. It was working through the system.

For this workflow, Codex — a paid tool — suddenly started to look redundant.

That is not a dramatic statement for effect. It is simply what happened during the work. After weeks of OpenAI-side changes and business-account friction, OpenCode Go was tried because something else was needed.

The result was not “slightly better.”

It was a genuine “why did we not try this sooner?” moment.

The cost is almost ridiculous

OpenCode Go is currently $5 for the first month outside the United Kingdom. In the United Kingdom, that came through at about £3.88 before processing fees.

For what it delivered in one working session, that is almost absurdly good value.

The current OpenCode Go model list includes:

• GLM-5
• GLM-5.1
• Kimi K2.5
• Kimi K2.6
• MiMo-V2.5
• MiMo-V2.5-Pro
• MiniMax M2.5
• MiniMax M2.7
• MiniMax M3
• Qwen3.6 Plus
• Qwen3.7 Plus
• Qwen3.7 Max
• DeepSeek V4 Pro
• DeepSeek V4 Flash

The model list may change as OpenCode tests and adds models, but the important point is this: DeepSeek V4 Flash has been astonishingly useful for real coding-agent work.

It is fast. It is capable. It is cheap enough that the included request allowance goes a long way.

OpenCode’s own estimates place DeepSeek V4 Flash at up to tens of thousands of requests across the included usage windows, depending on real request size and usage pattern.

That changes the way a developer can work.

Instead of treating every prompt like it is burning a hole through the wallet, it becomes possible to iterate, test, correct, inspect, and move forward.

What OpenCode Go includes

OpenCode Go works with usage limits expressed in dollar value rather than a fixed number of prompts.

At the time of writing, OpenCode Go lists:

• 5 hour limit: $12 of usage
• Weekly limit: $30 of usage
• Monthly limit: $60 of usage

That means the number of actual requests depends on the model selected. A lower-cost model such as DeepSeek V4 Flash allows far more requests than a more expensive model.

For practical coding work, that matters.

The workflow here was not one prompt and done. It was inspect, change, test, inspect again, correct the edge cases, then continue. That is exactly where a low-cost, capable coding model becomes powerful.

Why this matters for small developers and small businesses

Large companies can absorb expensive tooling mistakes.

Small companies cannot.

Independent developers, small technical businesses, and people building real systems need tools that work without creating another monthly financial headache.

That is why OpenCode Go is interesting.

It is not trying to trap the user inside one model provider. It is not saying every model must come from one company. It gives access to a curated set of coding-focused models, while still allowing OpenCode to be used with other providers.

That no-lock-in approach matters.

For AKADATA LIMITED, this is exactly the direction tools should be moving in: practical, interoperable, affordable, and actually useful.

The referral offer

OpenCode currently offers a referral programme.

Use this link and both sides receive a $5 usage credit when you subscribe to Go:

https://opencode.ai/go?ref=F31TPWD40H

That means:

1. You use the referral link.
2. You subscribe to OpenCode Go.
3. You receive $5 usage credit.
4. AKADATA LIMITED also receives $5 usage credit.

That is a fair exchange, and it helps support further testing, writing, and development work.

Try it on a real task

The best way to judge OpenCode Go is not to ask it something abstract.

Give it a real task.

Give it a repository. Give it database context where appropriate. Give it a bug that has been annoying you. Give it a feature that needs care rather than guesswork.

Let it inspect, reason, and work.

That is where it became impressive here.

OpenCode with DeepSeek V4 Flash did not merely answer questions. It helped move a live project forward.

For a first serious run, that is more than enough reason to recommend trying it.

And at the first-month price, with the referral credit available, it is one of the easiest technical recommendations to make right now.

Try OpenCode Go here:

https://opencode.ai/go?ref=F31TPWD40H

A birthday present came into the workshop.

Now it is being passed along.

From the Director,
AKADATA LIMITED