We're Building a Poker Platform and AI Just Tried to Deploy Our Infrastructure
Building a poker platform from scratch means wearing a lot of hats. On any given day I’m thinking about game logic, compliance requirements, player experience, financial transaction flows, and about a hundred other things that have nothing to do with each other. AI has been a genuine lifesaver for staying on top of all of it.
It also just tried to deploy our infrastructure when I asked it to write a paragraph.
The Setup
The poker platform runs on a detailed technical specification — a living document that covers everything: how the card engine works, how the ledger tracks player funds, how geofencing enforces Texas-only play, how venues get their white-labeled experience. It’s the foundation everything gets built from.
When it came time to formalize our Terraform infrastructure-as-code approach, I wanted to document the strategy in the spec. What patterns we’d use, how we’d structure our Azure deployments, the general philosophy. A section. A few paragraphs.
I asked AI to add it.
AI added a complete, runnable Terraform implementation instead.
Cool Code, Wrong Deliverable
Modules. Variable files. Resource definitions. A fully scaffolded IaC project — embedded inside a markdown specification document.
The kicker? The code was actually good. Solid module structure, clean resource organization, sensible variable naming. If I’d asked it to build the Terraform setup, it would have been a strong starting point.
But I asked it to describe the strategy, not execute it. There’s a meaningful difference between “document how we plan to use Terraform” and “here is Terraform.” A human would have caught that. AI confidently did not.
Why This Matters for a Poker Platform Specifically
A poker platform has a lot of moving parts that have to be right — not approximately right, not directionally right, exactly right. Game state, ledger entries, compliance rules, geofence logic. The spec is the contract between the design and the implementation. When something gets added to it, it has to be intentional.
An AI that helpfully generates code and drops it into the spec document without being asked isn’t just doing extra work — it’s potentially corrupting the source of truth that everything downstream depends on. In a codebase this sensitive, the blast radius of a misunderstood instruction matters.
This particular incident was low stakes and easy to fix. But it’s a good illustration of something worth keeping in mind as we build: AI executes confidently and asks questions rarely. The human in the loop exists to catch the gap between what was said and what was meant.
The Fix and the Lesson
Thirty seconds to delete the generated code. Thirty more to rewrite the prompt with explicit constraints: “prose only, no code blocks, describe the strategy.” Got exactly what I wanted on the second pass.
The practical takeaway: when prompting AI for documentation or spec work, treat it like you’re writing instructions for someone who will do precisely what you say and generously interpret any ambiguity as permission to do more. Because that’s what it does.
Be explicit about format. “Add a section about X” is ambiguous. “Add a prose section with no code describing our approach to X” is not.
Expect it to over-deliver in the wrong direction. AI leans toward doing more, not less. When the task is additive (like updating a spec), that instinct needs guardrails.
Read before you commit. This is obvious and somehow still the most commonly skipped step.
We’re building this platform in public — the wins, the weird detours, and the moments where the tools do something unexpectedly hilarious. This was one of those moments.
AI is genuinely remarkable for a project like this. It’s also, occasionally, a little too eager to help.
The poker platform is coming along. More soon.
