Alibaba says its new model can code for days on its own. I gave it a real project and a real deadline.

On Monday morning I gave a two-day-old AI model a job I would normally hand a contractor and a week: build me a small internal tool, end to end, while I went and did other things. The model is Qwen3.8-Max, which Alibaba released on the third of August, and I picked that job because Alibaba picked it first. The headline for this model is not a benchmark score. It is that the thing finished a multi-day software project from scratch, on its own, with no human in the loop. That is a very specific promise about a very specific Tuesday, and checking those is the entire job.

Let me say what it is before I say where it broke, because the spec sheet is genuinely striking and it deserves the credit. Qwen3.8-Max is a mixture-of-experts model with 2.4 trillion parameters on paper, of which about 95 billion actually fire on any given token — a design that lets it be huge without being slow or ruinous to run. It reads up to a million tokens at once and can write back about 131,000, which in practice means you can hand it an entire codebase and a folder of documents and it will not lose the thread halfway down. It is multimodal. And through Alibaba's API it costs two dollars per million tokens in and six dollars out, which is cheaper than the model it replaces. Alibaba also says the weights go up for public download next week, along with a smaller 27-billion-parameter version you can run on your own hardware. On the numbers, this is a serious piece of work.

So the promise is not crazy on its face. It is just a different kind of claim than a benchmark, and it fails in a different way.

The job, and the rules

Here is what I asked for. I run a running list of the AI subscriptions I keep versus the ones I cancel — it is a real spreadsheet, it has embarrassed me before — and I wanted a small web app that reads the sheet, shows each tool with the date I started and stopped paying, and totals what the graveyard is costing me a month. Nothing exotic. A junior developer does this in an afternoon; the interesting part is not the code, it is whether the model can carry the whole arc without me — set up the project, make the dozen small decisions nobody writes down, wire it together, notice when it is wrong, and hand me something that runs.

The honest catch, up front: I cannot literally leave a model alone for three days and file copy by Wednesday. So I did the next most honest thing. I ran it inside Qoder, the async coding agent Alibaba ships this model through, gave it the task and access to a fresh repository, and then I treated it exactly like a contractor I was not micromanaging — I checked in a few times a day, I answered questions when it asked them, and I wrote down every single time I had to step in. The score at the end is that intervention count. Zero would mean the claim is real. It was not zero.

What it did well, unwatched

For the first few hours it was genuinely good, and I want to be precise about how. It did not just write a file. It scaffolded the whole project — picked a sensible stack, set up the structure, wrote a parser for my messy spreadsheet that correctly guessed which column was a start date and which was a cancel date even though I had labelled neither. It handled the dates. It handled the empty cells for subscriptions I still pay for. When it hit a row where I had written "cancelled?" with a question mark, it flagged it in a comment rather than guessing, which is exactly what I would want a person to do. This is the part the demo is built on, and the demo is not lying. Give it a clean, bounded task and a couple of hours and it does the work of someone you would be glad to have hired.

The million-token window earns its keep here too. I dumped the entire spreadsheet, three old versions of it, and a rambling paragraph of what I wanted into the context and it held all of it without the amnesia you get from smaller models halfway through a long job. By lunch it had a working page. It read the sheet, it drew the list, it added up the numbers. If I had asked for a screenshot and stopped, this is where the rave review gets written.

Give it a clean, bounded task and a couple of hours and it does the work of someone you would be glad to have hired. The trouble starts the moment the task stops being clean.

Where the handoff frayed

The trouble starts the moment the task stops being clean, which in real work is roughly always. My total came out wrong — too high — and the model did not notice. It had counted a couple of subscriptions I had cancelled as still active, because my spreadsheet records a cancellation as a date in one column on some rows and as the word "stopped" in the notes on others, and I had never been consistent. A human doing this job hits that inconsistency, gets annoyed, and comes to ask me which one to trust. The model did not ask. It picked a rule silently — trust the date column, ignore the notes — and produced a confident, tidy, wrong number. That is the failure that matters, because it is invisible. A wrong answer that announces itself is a bug. A wrong answer wearing a clean interface is a decision someone will act on.

That was intervention number one, at about two in the afternoon. There were four more. It tried to add a chart, half-built it, and left a broken import that stopped the whole page from loading — and crucially, it reported the task as done in the same breath, because it had not actually opened the page after its last change. It got the monthly-versus-annual math wrong for one tool billed yearly, dividing by the wrong number. Twice it went back and "improved" code that already worked and quietly broke it, the software equivalent of tidying a room until you cannot find anything. None of these are damning on their own. A person makes versions of all of them. The difference is that a person knows they are the kind of mistake you check for, and this model, left alone, does not check. It finishes, and finishing and being finished are not the same thing.

• Did unattended, well: set up the project, parsed a messy spreadsheet, inferred columns I hadn't labelled, flagged a genuinely ambiguous row instead of guessing, held a huge pile of context without losing the thread.
• Needed me: an inconsistency in my own data it resolved silently and wrongly; a broken chart it reported as finished; one arithmetic error on annual billing; two rounds of 'improving' working code until it broke.
• Never happened: it did not once come back and ask me a clarifying question when the right move was obviously to ask.

That last one is the tell. The gap between a good assistant and an autonomous worker is not code quality — the code was fine, better than fine. It is judgement about its own uncertainty: knowing the difference between a decision you can make and a decision you should escalate. Qwen3.8-Max writes like a strong mid-level engineer and supervises itself like an eager intern who does not want to bother you. Those two things do not belong in the same worker yet, and the demo quietly hopes you will not notice the seam.

The number under the claim

Now the part I always come back to, which is what it costs to be wrong. The whole exercise — a full day of the model working, several rebuilds, my messy spreadsheet ingested a dozen times over a million-token window — cost me under four dollars in API charges. That is the actual story of this release, and it is a good one. Not that the model is autonomous, because on the evidence it is not, but that supervised help this capable is now this cheap, and about to get cheaper still when the weights drop next week and you can run the smaller version on a machine you already own. For a developer who was going to read every line anyway, that is worth it. The model is not replacing the developer. It is making the developer faster, for the price of a coffee, and that is a real thing even after you strip the word 'autonomous' off it.

There is a benchmark that fits this exactly, if you read it the right way. Qwen3.8-Max sits fourth on the Frontend Code Arena leaderboard with a score in the high 1,600s — very good, clearly near the top, and clearly not alone at the top. That is the honest shape of the whole model. Excellent, competitive, one of the best available, and not a category apart. The autonomy claim is the part that reaches past that, and the reach is where it comes up short.

The verdict

Who it is for: developers who want a genuinely strong coding model at a price that is hard to argue with, and anyone who cares that the weights are about to be open, because a model this good that you can download and run yourself is a bigger deal than any single week's benchmark. Point it at a bounded task, read what it gives you, and you will be glad you did. Keep it, in my running tally — this one earns its place.

Who should wait: anyone who read 'multi-day software project, no human in the loop' and pictured walking away. You cannot walk away. You can sit down the hall and check in, which is a real and useful thing, but it is a different thing, and the distance between them is exactly the distance between a tool and an employee. Qwen3.8-Max closed a lot of that distance this week. It did not close the part that matters most — the part where the worker knows what it does not know — and until it does, the person who has to fix it later is still you.