Rebuilding a live game in its existing codebase

TriviaPot started as real-time trivia played for a cash pot. From May onward, Descant’s research prototype carried out the development fully autonomously. We kept the repository and its history, gave it the rebuild, then changed direction: a full visual redesign and a free-to-play release for the App Store. The work carried through matchmaking, live gameplay, party rewards and the mobile experience while Descant itself evolved alongside it.

  • 2,076 fully autonomous prototype PRs merged

    From May onward, the system carried the work through gameplay, party rewards, mobile navigation and release.

  • 2,117 PRs opened from May onward

    The full body of work, from rebuilding the game to its visual redesign and public release.

  • 300/354 merged PRs in the retained subset changed tests

    Tests evolved with the implementation. The examples show checks strengthened to catch failures that earlier tests missed.

  • Live free-to-play trivia on iPhone

    The rebuild and visual redesign reached a public release that players can use.

Change the product where it already lives

Keeping the repository preserved earlier decisions and working code as references throughout the rebuild. Changes still had to fit the surrounding application. Sharing emerald rewards with a party, for example, had to agree everywhere from the final allocation to the number shown on each player’s recap.

Carry a deliberate change of direction through to release

By early July, the core game was working. We then chose a full visual overhaul and removed real-money features for the free-to-play release. That new scope expanded the backlog again. Descant carried the redesign and follow-up work across the application; by September 3, the public website pointed to the live App Store listing.

Keep the evidence attached to the result

The retained record includes mistakes caught before merge, tests improved after they proved too weak, follow-up work split into manageable changes, and earlier learnings applied to later problems. Six concrete examples show what changed and how we know.

The recorded work

From May onward, Descant’s research prototype performed TriviaPot’s development fully autonomously: 2,117 PRs opened and 2,076 merged. The detailed test, review and learning metrics below cover a retained-session subset: 358 PRs linked to 352 parent sessions across two machines, with 354 merged. That subset is evidence for how the system worked, not the total work it produced.

  • 300/354 merged PRs in the retained subset changed tests

    The examples show database tests catching a missed defect and deliberate breakages exposing a test that passed for the wrong reason.

  • 590 test source paths changed in that subset

    The changes reach game services and mobile behavior, including party settlement, queue entry and navigation.

  • 32/354 merged PRs in the retained subset updated learnings

    Those prototype changes left explanations available to later work, alongside the code and tests.

  • 36 learning documents changed in that subset

    Distinct document paths changed in the cohort; the learning example separately demonstrates a prior lesson being used.

Repository output through November 2, 2026 UTC · retained-session analysis from November 1

Fully autonomous development from May onward

2,117 PRs opened and 2,076 merged during the fully autonomous prototype period, May 1 through November 2, 2026 UTC.
GitHub creation and merge events from May 1, 2026, 00:00 UTC through the final PR event on November 2 at 00:21 UTC. Two merged PRs were opened before May. Tim, the founder and operator, confirms this was fully autonomous prototype work, including the later September and November changes.

Issues created and closed

2,665 repository issues created, 2,497 closed and 168 still open at the last issue event on August 28, 2026.
The complete repository issue history, including reopenings. Of 2,497 closed issues, 2,283 are marked completed and 214 not planned. The line ends at the actual final issue event on August 28.

The full repository history

2,353 pull requests opened and 2,298 merged across the complete repository history, through November 2, 2026 UTC.
The complete history includes the earlier application and the fully autonomous prototype work from May onward. The May marker shows where that period begins. The chart ends at the final recorded PR event, with no projected tail; PR totals are not run counts.

What changed in the software

Make party rewards agree from settlement to the recap

A full party playthrough showed Gold being shared while emerald rewards stayed with their original winners. Emerald pooling had never been implemented, and existing tests described that omission as intended behavior.

The change carried settlement-won emeralds through allocation, accounting, recovery and the game recap. A party winning 100 emeralds now receives shares of 34, 33 and 33. Emeralds earned during questions stay individual, preserving rewards players had already watched accumulate.

The merged change covers three filters that could silently discard an emerald-only result. Tests address settlement, the displayed split, older and newer app versions, and repeat processing. The old exclusion assertion was rewritten to reflect the intended behavior.

Check affordability before a player waits for a match

A player holding 200 Gold could choose a 500-Gold entry and enter the queue. The rejection came only after a match was found, wasting the wait and leaving the forming table short a player.

The app selects an affordable entry when balances load and explains an unaffordable manual choice. The server checks funds before inserting queue entries. Party rejection identifies the affected member without returning their balance; an unread balance is kept distinct from zero.

Acceptance scenarios and regression tests cover solo, party and failed-balance-loading paths. Review also corrected compatibility with older app versions and a disagreement between the banner and button. The change explicitly leaves the later spend-after-enqueue window outside its scope.

Replace mocked confidence with a test of the actual query

Two notification-delivery paths built an invalid database query. Their tests substituted a fake database, so the malformed query was never executed.

The workflow fixed both paths and added tests against a real database for one recipient, multiple recipients, inactive-token exclusion and separation between users. It recorded the underlying mistake in a learning document.

The merged diff contains the behavior fix, five integration tests and the learning. The historical verification report says the new suite passed, then failed when the old query was restored. That tests the missing failure mode as well as the correction.

Apply an earlier learning, then test the test itself

An initial concurrency test waited a fixed amount of time and assumed that an operation was blocked. Even after that timing shortcut was removed, an unrelated setup step could still make the test pass.

A researcher retrieved an earlier learning and the builder read it. The test switched to inspecting the actual blocked operation. Deliberately removing the protection under test exposed the remaining false positive, prompting a fixture that isolated the intended protection.

The retained read and action records connect the earlier document to the new implementation. The recorded final check failed with the protection removed and passed when restored; the corrected fixture and its explanation are present in the merged test.

Finish a decomposition instead of leaving a larger backlog

A real-time game service had grown to roughly 1,728 lines. A follow-up issue called for separating responsibilities so changes would be easier to understand and test.

The work was split into four concrete tasks: reading recipient frames, managing ownership leases, maintaining subscriber sessions and delivering events. Each task shipped as its own pull request, with progress recorded on the parent issue.

All four changes merged between June 30 and July 1, and the parent closed after the final child. In the ownership extraction, the existing service-level test files stayed unchanged while a focused new test suite covered the extracted behavior.

Follow a recovery journey beyond the new button

In an earlier cash-play version, a player blocked from joining a match received a generic error. Adding a verification action exposed navigation inherited from a different flow.

Review followed the whole journey: the return destination, another match-entry screen and timers that could interrupt verification. The author made return routing aware of the originating screen and corrected the additional navigation paths.

Nine pre-merge review threads have specific author replies and are marked resolved; the corresponding navigation corrections and regression tests are in the merged change. A tenth thread arrived after merge and remains unresolved in the snapshot.

Learning that the next change can use

The retained records show 2,219 successful reads of 502 distinct learning documents across 192 of 299 parent sessions in the first archive. Repeated reads count separately. The second archive lacks comparable per-read detail, so it is excluded from these retrieval figures.

Retrieval establishes that the document reached the session. The concurrency-test example goes further: a prior learning changed the implementation, and deliberately removing the protection exposed a second flaw in the test. The builder adapted the fixture until the test detected the regression it was meant to catch.

Knowledge also changed in the repository. 32 merged PRs in the retained-session subset touched 36 distinct learning-document paths. The November 1 product tree contains 653 learning documents and 1,607 test source files, up from 209 test source files before April. Those inventories cover the whole project.

  • 2,219 successful reads of prior learnings

    Recorded in the first archive’s cohort, including repeat reads. Retrieval establishes that the document reached the session.

  • 502 learning documents retrieved

    The sessions could consult earlier explanations across the project. The concurrency-test example traces one through to an improved test.

  • 192/299 sessions retrieved a prior learning

    These are parent sessions in the first archive only; the second archive lacks comparable per-read evidence.

Sources and method

Tim Layton, the founder and operator, confirms that all TriviaPot development from May 2026 onward was performed fully autonomously by Descant’s research prototype. GitHub records supply the output counts. Retained sessions supply additional evidence for a subset; their survival does not define the extent of the autonomous work.

Within the retained-session subset, 119 PRs have 590 visible review threads. The examples connect specific concerns to author responses and merged changes; a resolved thread alone is not counted as a fixed defect.

The product is public; its source and session archives are private. The downloads contain aggregate chart data, definitions and paraphrased examples. Private code, raw conversations and session identifiers remain outside the published material.

Counting rules and coverage
  • The prototype period begins May 1, 2026 at 00:00:00 UTC. Creation and merge events are counted separately through November 2 at 00:21:01 UTC. Of the 2,117 PRs opened in the period, 2,074 merged and 43 closed unmerged. Two April-created PRs also merged in the period, bringing the merge-event total to 2,076.
  • The November 1 census covered every repository issue and PR, with reviews, comments and review threads paginated to their recorded totals. A November 2 metadata refresh added the latest merged PR to the output counts. The 358-PR retained-session subset requires a successful PR-creation result and an explicit workflow signature; records are deduplicated across two archives.
  • All 354 merged PRs in the retained-session subset have mapped source diffs. Test counts identify changed test-source paths; they do not count passing tests. Learning-document changes, successful retrieval and demonstrated application are reported separately.
  • Issue charts reconstruct creation, closure and reopening events. PR charts record creation and merging. Each chart ends at its own last event; an open PR is not evidence of an executing agent.
  • The examples use committed code, historical verification reports and retained review or session records. This census did not rerun the product’s historical test suites. Costs, time saved and a complete ledger of prototype attempts are unavailable. The published chart data and reproduction script independently recalculate the period totals from the complete repository event history.

Start with an issue worth solving

Give Descant a real piece of work. Inspect the code, review the result and see what delivering it cost.