Claude Opus 5.5 on 10 Real Projects: What Benchmarks Do Not Show

▶️ Watch the full video

Anthropic presents Claude Opus 5.5 as performing close to Fable 5.1 on most tasks while running faster and costing less than Opus 5. Those figures are useful reference points, but they do not show what happens when the model receives an empty workspace, one assignment and a time limit.

I ran ten different projects without my skills, MCP servers, personal configuration or human edits. Each project used an isolated environment, the same protocol and a 30-minute maximum. This was not meant to become a scientific leaderboard. I wanted to see what Opus 5.5 could deliver on its own, where it struggled and what the outputs actually proved.

The test protocol

I kept four rules constant across all projects:

1. Same starting point: an isolated workspace with no personal context.
2. Same assistance level: no manual correction during execution.
3. Same constraint: no more than 30 minutes per project.
4. Same minimum proof: the project had to finish, start with one command and produce an inspectable result.

The ten assignments covered 3D visualisation, simulation, web interfaces, a dashboard, a product configurator, a game and a REST API backed by SQLite. That variety matters more than asking for ten similar landing pages. It makes the model handle different project structures, libraries and success criteria.

The ten projects given to Opus 5.5

Family	Project	What the model had to handle
3D	Black hole with an accretion disk	Scene, animation, rendering and visual lensing
3D	Galaxy with thousands of particles	Generation, movement and display performance
Simulation	Procedural roller coaster	Geometry, track and camera
Simulation	Vortex mechanism	Coherent motion and visualisation
Simulation	Particle flow	Continuous updates and smooth rendering
Frontend	AI SaaS landing page	Visual hierarchy, components and responsive layout
Frontend	Product configurator	State, options and dynamic summary
Data UI	Analytics dashboard	Data, charts and readability
Game	Platformer	Controls, collisions and game loop
Backend	REST API with SQLite	Routes, persistence and automated tests

Results: ten completed projects, but not ten identical proofs

The run produced the following results:

• 10 out of 10 projects finished without a blocking error;
• 10 out of 10 start with one command;
• 9 out of 9 test suites written by the model pass;
• 1 hour 46 minutes of cumulative autonomous work;
• $20.45 in equivalent API cost;
• 514.6k output tokens generated.

The useful result is not the 10/10 score by itself. It is the combination of autonomy, task variety and the ability to make every project runnable. A repository full of files is not enough. Starting the output quickly lets you inspect what was actually built.

The video shows all ten outputs rather than a curated selection: watch the complete test.

What the test shows about Opus 5.5

1. It can carry a short project from start to finish

For these bounded tasks, Opus 5.5 did more than write one component or function. It created the structure, selected dependencies, implemented the result and prepared a launch command. That continuity is what makes a model useful in an agent workflow.

2. Visual tasks no longer stop it from shipping

The 3D projects and simulations require more than static HTML. The model has to combine a scene, parameters, animation and a visible output. These results do not replace human art direction, but they provide functional prototypes that can be inspected and corrected.

3. Backend work remains easier to verify than visual work

The REST API provides clearer evidence: routes, a SQLite database and 52 tests in that project. Passing tests do not prove that the product meets every need, especially when the model writes its own tests. They still give us a more objective verification surface than an attractive screenshot.

4. Cost only matters when attached to an outcome

$20.45 can look cheap or expensive depending on what you measure. Token totals alone do not help much. The useful question is how many runnable prototypes, tests and technical decisions were produced for that cost. Here, the number has context because it is attached to ten observable deliverables and 1 hour 46 minutes of autonomous execution.

The limits of this experiment

This is not a universal benchmark.

• The ten projects cover several families, but they do not represent all software development.
• A 30-minute limit favours short prototypes and penalises work that needs a long analysis phase.
• The same model wrote the code and the tests. Independent review is still required.
• “Completed” means runnable under this protocol, not production-ready, secure or maintainable for three years.
• The cost is an API equivalent for the run. It excludes human review and later corrections.
• Price, speed and performance comparisons with Opus 5 or Fable 5.1 come from Anthropic’s announcements, not from independent measurements in this experiment.

A practical workflow for models like this

The experiment points to a straightforward approach: give the model a verifiable scope, then separate generation from validation.

1. Define an observable result and a launch command.
2. Provide concrete acceptance criteria, not a broad intention.
3. Run the work in an isolated environment.
4. Request tests when the output supports them.
5. Start the project and run the tests instead of trusting the model’s report.
6. Have another agent or a human review the code and tests.
7. Fix functional defects before expanding the scope.

This prevents us from confusing generation speed with final quality. The model can produce a lot in little time. The value comes from the proof contract around that work.

My verdict

Opus 5.5 delivered ten runnable prototypes out of ten under this protocol. That is a strong signal for short, bounded and verifiable assignments. It does not remove the need for review, independent tests or product criteria. It shows that a powerful model becomes more useful when it receives a clean environment, a clear boundary and evidence it must produce.

▶️ Watch the ten projects, protocol, costs and limitations

For my next AI-agent tests and development workflows, join The Agentic Dev.