The Loop Is Getting Better at Telling Us We Are Not Done

TL;DR

Wordulate is making steady internal progress across puzzles, offline recovery, boosters, account protection, and test-ad privacy. We have also made our agentic development loop explicit. Agents build, test, and correct. The studio provides ownership, independent review, and human decisions. The goal is not to give agents more authority. It is to give every decision better evidence.

It has only been a few days since my last Wordulate update, but they have been busy. We have merged improvements to Daily Puzzle timing, leaderboard behavior, offline recovery, boosters, account protection, and test-ad privacy. Newer Android and iOS builds have also moved through our internal pipeline.

Wordulate remains in internal development, and the newest corrections still need a fresh installed build.

This week I have been thinking less about any one feature and more about how we are building the game. We use Codex agents across production, client engineering, server engineering, review, analytics, and marketing. I have called this an agentic workflow before. A more accurate name is our agentic development loop.

When AI engineers talk about an agentic loop, they often mean the cycle inside one agent: understand the task, make a change, test the result, and adjust. We use that pattern, but we also put a larger production loop around it.

The inner loop belongs to the agent. The outer loop belongs to the studio.

I describe the player experience or problem. Production scopes the work. The right engineering lane implements and tests it. The Game Director reviews the exact change. We merge it and, when separately approved, put it into staging or an internal build. I play it. What happens becomes the next input.

Making the loop explicit

We already had focused roles, pull requests, automated checks, and separate approvals for builds and deployments. What we lacked was one clear set of implementation rules. Work could start from old code, a review could become stale, or several agents could report status without anyone owning the next move.

Every authorized source change now starts with a short packet naming the owner, exact starting point, scope, exclusions, expected proof, and actions that still need a separate decision from me.

The implementation agent works in isolation and begins with a repeatable problem. Each pass tests one idea, with focused checks before broad ones. If different ideas reach the same failure, the agent stops. The number of passes is also limited.

GitHub remains the shared record. We do not create a hidden second ledger or commit broken work just to look busy.

The Game Director reviews the exact version. If it changes, it gets reviewed again. Builds, deployments, store actions, and installed tests remain separate steps after source review and merge.

In plain English, the loop asks:

1. Who owns this?
2. What exactly are we changing?
3. What does the evidence prove?
4. What still has to happen before we are done?

When the loop earns another pass

Our latest internal Android test gave us a good example.

The build opened, connected to staging, and displayed a Google demo banner. Then I completed a level. The Next button appeared late, flickered, and the game advanced on its own.

That was not the experience I wanted. The end-of-level moment should belong to the player.

We stopped testing and traced the problem to gameplay paths that worked separately but failed in that sequence. The correction is merged with new tests for the result screen, reconnecting, restarting, delayed responses, and repeated taps. The next installed build will validate the complete experience.

The same test found a booster screen that could load forever. Review found that the first correction could still hang during cleanup, so it went around the loop again before merge.

Account protection followed a different path. We had made progress on numeric codes, but I changed direction to email links because they seemed clearer for players moving between devices. That meant discarding mature work. Later, an Android test showed that a link did not send in that attempt and the message was too vague. The follow-up passed source review, but still needs to merge and reach a new build.

These extra cycles are useful when each pass changes the evidence, product, or process.

Agents do not own the promise

The agents are good at carrying technical context, comparing client and server behavior, writing regression tests, and keeping corrections moving. They are also literal when the rules are clear. Approval for one version does not apply to another. A failed one-use build number stays spent. A test says what it proved, not what we hoped.

But agents do not decide what Wordulate should promise.

I decided that the player owns the Next button. I changed the recovery method. I decided that accounts with meaningful progress or value should not be combined by a guess. I decide when a feature is not ready.

Production protects sequence and ownership. Engineering implements. The Game Director supplies independent judgment. Analytics measures carefully. Marketing keeps internal progress from becoming a public claim too early.

This process makes the work easier to audit and harder to wave through. It has caught stale approvals, turned review findings into tests, preserved failed build history, and let device evidence overrule a confident source-level story. It gives us a dependable way to move quickly without confusing activity with progress.

The loop is not getting better because the agents stopped making mistakes. It is getting better because mistakes now have somewhere useful to go.

Wordulate is not publicly launched. The next installed build will validate the newest result-screen, booster, and recovery work. Rewarded and interstitial testing continues with test inventory. Real ad inventory remains off.

My job is still to decide what kind of game we are making and what promises we are willing to make to players. The agents help us move through that work with better memory, clearer ownership, and stronger evidence.

The loop is getting better at telling us when we are not done.