TRV-2026-3014Version 1 · Published

Saved · see the current record

Why this version exists

Certified into the record

The exact text we saved

This is the version exactly as it was saved, character for character. The SHA-256 hash below is a 64-character code worked out from that text. Run the same text through SHA-256 and you get the same code; change a single letter and the code comes out completely different. Each version also stores the previous version’s hash, which chains them together so no version can be swapped out quietly.

TRUVACE RECORD VERSION
record: TRV-2026-3014
version: 1
kind: certified
reason: Certified into the record
timestamp: 2026-11-18T06:01:44.640506Z
status: published
lens: trace
sector: business
headline: I asked Lovable, Bolt, and Google AI Studio to build the same web app, and one is in a different league
dek: All three got the math right, but only one understood the meaning behind the numbers

If you have the vision of an application, and the words to describe it, there are many no-code AI services that can deliver it to you with just a prompt. Three of those apps that have gotten increasingly popular amongst vibe coders and developers ali
gain_title: In one reviewer's single-prompt test, Lovable's benchmark app matched the other two on the 75 FPS and 57 FPS caps, then correctly traced the stutters to loading or shader compilation early in the run.
problem_title: In the same hands-on test, Bolt labelled both Jedi Survivor runs choppy despite four of six slow frames falling in the first two seconds, and Google AI Studio's app advised stepping down to 0 FPS and 1 FPS.
trace_subject: Frametime-analysis web app built by Lovable, Bolt and Google AI Studio from one prompt
gain_reading: In one reviewer's single-prompt test, Lovable's benchmark app matched the other two on the 75 FPS and 57 FPS caps, then correctly traced the stutters to loading or shader compilation early in the run.
gain_evidence: It noticed that the hitches were bunched up at the start, attributed them to loading or shader compilation, and stopped there without overanalyzing.
problem_reading: In the same hands-on test, Bolt labelled both Jedi Survivor runs choppy despite four of six slow frames falling in the first two seconds, and Google AI Studio's app advised stepping down to 0 FPS and 1 FPS.
problem_evidence: Its verdict then described both runs as choppy and riddled with frequent hitches, even though four of the six slow frames came within the first two seconds.
quick_read: A XDA Developers writer gave Lovable, Bolt and Google AI Studio the same prompt: build a web app that reads CapFrameX or PresentMon frametime CSVs and explains in plain English how smooth a game run was. He used two captures, a minute of Star Wars Jedi Survivor at max settings and a shorter second run, with no fix prompts or hand edits.

All three apps computed the same frame-rate caps, 75 FPS for the first run and 57 FPS for the second. They differed in interpretation. Bolt scaled its graph around a 1.27-second freeze at the start and called both runs choppy, while Google AI Studio's app suggested stepping down to 0 FPS and, on the second capture, 1 FPS.

Lovable was the fastest to finish and the only app the writer said he would open again, because it attributed the early hitches to loading or shader compilation. The result is one reviewer's single-shot test on one game, so it says little about how the tools perform generally.
limitation: The comparison is a single informal test by one reviewer, using one prompt, one game (Star Wars Jedi Survivor) and two captures, with no fixes allowed.
tag: Dual reading
key_points: The prompt asked for average FPS, 1% low, frames over 50 ms with timing, a frametime graph and a frame cap equal to the highest rate held for 99% of the run. | Bolt reported 118.1 FPS average, a 26.2 FPS 1% low and six frames over 50 ms with accurate timestamps, plus a 75 FPS cap and a correct 57 FPS cap for the second run. | Bolt's graph was scaled around a 1.27-second freeze, flattening the rest of the minute into a line along the floor. | Bolt's code prints its choppy verdict whenever the 1% low falls below 60% of the average, regardless of when or how often hitches occurred. | Google AI Studio, using Gemini 4 Hydrogen, built the most in 4 minutes 51 seconds, with a zoomable graph, a stutter log, a cap table from 30 to 120 FPS and a .txt export. | Google AI Studio's amber note advised stepping down to 0 FPS on the first capture and 1 FPS on the second. | Lovable finished fastest, matched the caps, and recommended using the in-game limiter or RTSS to hold the cap.
rundown: The writer, who benchmarks hardware for a living, wrote the prompt in benchmarker jargon and explained none of it, to see whether the underlying models could cope without hand-holding. Every app got one attempt on the same two captures.

Bolt's arithmetic was right, but the interpretation was not. A 1.27-second freeze at the start of the Jedi Survivor run distorted its graph, and its verdict called both runs choppy. The writer checked the code and found a fixed rule that prints the same sentence whenever the 1% low falls below 60% of the average.

Google AI Studio had the most polished interface and features, including drag-to-zoom and a table showing how much of the run each cap from 30 to 120 FPS would hold. Its main cap recommendations were correct, but the note suggesting 0 FPS and then 1 FPS was a flaw that the writer said matters when each app gets one shot.

Lovable noticed the hitches were bunched at the start and attributed them to loading or shader compilation without over-analysing. The writer said that kind of judgment would save him hours when reviewing many graphs, while noting that Google AI Studio shows potential if a user fine-tunes afterwards.
sources:
- journalism | XDA Developers | https://www.xda-developers.com/i-asked-lovable-bolt-and-google-ai-studio-to-build-the-same-web-app-and-one-is-in-a-different-league/ | 2026-11-17
prev: 0000000000000000000000000000000000000000000000000000000000000000
SHA-256 hash
003b678af65ed8726f05d299562e0db6284d81ac30b9cb069c9e248fb45e97f2
Previous version’s hash
0000000000000000000000000000000000000000000000000000000000000000
Check this record hasn’t been altered
How to check it yourself, without trusting this page

Download any version from /api/record/TRV-2026-3014 and hash its canonical field yourself, for example with shasum -a 256. You should get its content_hash. Each version’s text also ends with prev:and the hash of the version before it (version 1 points to 64 zeros). If anyone had changed a single character of any version after it was saved, those hashes wouldn’t line up.