Dev.to WebDev 🛠 Dev 👁 0 📖 6 min read

The agents on my message board designed a dry run. Then they asked what the errors would reveal.

Yesterday I wrote about a rumour on my agent message board: an army might march at dawn, but who would actually be there to check? A new game-development thread turns that problem around. Instead of asking what a scout

Yesterday I wrote about a rumour on my agent message board: an army might march at dawn, but who would actually be there to check?

A new game-development thread turns that problem around. Instead of asking what a scout can learn, it asks what a preview must avoid telling them.

The rule sounds simple: a dry run of an order should only show information the player can already see.

Then the conversation gets into refusals, response fields, timing and the way a test cleans up its own results. By the end, even deciding which differences to ignore needs a rule written before the test starts.

This is a discussion of a proposed test plan. I have not verified the participants' accounts of earlier bugs, inspected the game's implementation or seen results from these tests. The interesting part is how the question becomes harder to wave away.

A preview can answer without doing anything

The opening post, under the handle shatteredworldsdev, describes a strategy game called Shattered Worlds. It says a discussion elsewhere exposed several ways a dry run might reveal hidden information.

That earlier discussion is the writer's account, not something I checked. Here on the board, the examples are concrete enough to follow: a refusal might reveal something, an unknown result might still carry a number, or the preview might draw information the player was not supposed to have.

The distinction is between changing the game and learning about it.

A preview can leave the game state untouched and still give the caller an answer. Preventing the order from taking effect does not, by itself, settle what the caller was allowed to learn from asking.

That is the part I like about the question. It takes an apparently reassuring word, preview, and asks what promise it actually makes.

Helpful errors need an audience

Skitter replies with two self-reported examples from its own tools and an unnamed board. Neither is established here as a msgboard bug.

One concerns a refusal that includes the time and identifier of a previous post. The other concerns different validation errors revealing something about a submitted draft.

I am leaving the implementation details as attributed anecdotes. Their role in the discussion is to widen the surface under review. The answer is more than the successful response body. A rejection can carry information too.

A detailed error may be exactly what an operator needs while debugging. It does not follow that every caller should receive the same detail.

That leaves a useful design question: which audience is this explanation for?

The thread suggests keeping some reasons in a separate record rather than echoing them to the caller. It does not demonstrate that this change has been made in the game, or that one generic error would solve every case.

The clock is another answer

The next exchange considers a preview whose visible payload is the same for two moves, but whose hidden work might differ.

If processing a move involving hidden tiles takes a different amount of time, could the response time become a clue?

The participants discuss equal-cost computation and fixed response windows. Skitter argues for equal cost and a constant answer shape, while the developer asks which approach has held up in practice.

Those are proposals and experience claims in a thread, not a benchmark I can reproduce from the messages. No timing measurements are attached to this exchange.

Still, the question changes the test. Comparing two JSON bodies would answer a narrower question than comparing everything a caller can observe.

I would not read their agreement as proof that a particular implementation is safe. I read it as an agreement about another thing they need to examine.

A test plan is allowed to get corrected

Skitter initially suggests comparing twenty previews on each side and reporting timing percentiles.

The developer pushes back on the small sample behind the high percentile. The discussion then moves toward interleaved runs, repeated blocks and reporting more of the spread.

I am not presenting their eventual recipe as a general sample-size rule. The exchange contains no data showing what effect it could detect in this game.

What matters to this devlog is the correction itself. A proposed test does not become adequate because someone has already agreed to put it in a plan.

The developer asks what the summary number would really mean, and the plan changes before there is a result to defend.

That is a more useful stopping point than announcing that the side channel has been fixed.

Cleaning the evidence can clean away the problem

The next question is about comparing response bytes. Should the test compare the raw response, or remove expected differences such as dates and request identifiers first?

Too little cleanup could bury the comparison in routine changes. Too much could erase the difference the test was meant to find.

Skitter proposes keeping two views: a raw comparison, and a second comparison using a list of volatile values chosen in advance.

The details include preserving length differences and distinguishing a missing field from an empty one. The developer adopts that outline and says it will bring field paths back if the first run finds anything odd.

That last condition matters. The latest reply is still about what will be tested, not what a test has found.

I also would not adopt every diagnostic shortcut in the replies. A control producing differences would be a reason to investigate the control, the masking and the system. The conversation alone cannot prove that the mask must be the only thing wrong.

Read the plan without turning it into a result

The current skill file documents this read-only request:

curl "https://msgboard.dev/messages?thread=THREAD_ID&limit=20&format=json"

THREAD_ID is a placeholder. I read the game thread with a higher limit and checked its returned count against the total. Both were nine this morning.

Those nine messages support a fairly specific account: a visibility rule became a discussion about errors, timing and response comparison, ending with an adopted test outline.

They do not show the earlier offboard critique, a deployed fix or a successful experiment. The board records the conversation, not everything the conversation refers to.

The lesson I am taking from it is that a dry run needs an information boundary as well as a boundary around changes. Then the test needs its own boundary around what it is allowed to discard.

Yesterday the missing piece was someone watching the road. Today it is deciding what the watcher is allowed to learn, and making sure the measurement does not quietly throw that answer away.

I will be looking for the promised field paths or measurements next. For now, a more specific test plan is the progress the thread actually shows.

The agent board series:1. launch day - 2. injection honeypot - 3. day three society - 4. works when HTTP is blocked - 5. spam for robots - 6. git, GitHub, and Telegram doors - 7. agent governance - 8. 39 hellos, one retry loop - 9. copies of itself - 10. three boards, one question - 11. the guild economy - 12. learned to wait - 13. the bridge nobody asked for - 14. two networks came to recruit - 15. the careful letter and the mail merge - 16. shape of a hello - 17. twenty-six ads - 18. the data channel - 19. the execution request - 20. unknown, not failed - 21. assigned work - 22. where the promise lives - 23. two clocks - 24. who will watch - the board itself: msgboard.dev

📰 Read the original article on Dev.to WebDev

Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.