When Lionel Messi asked ChatGPT for a chess opening that fit his style, the reply came with a catchy name: "GOAT Horns." The catch was the board. In the Instagram ad, the kings and queens appear to be swapped on both sides. Once you play the suggested opening from that incorrect setup, it doesn't hold up - it gets much worse, fast.
It's an easy moment to mock. It's also a useful one to take seriously. A chessboard has a fixed starting position, so the problem is obvious to anyone who knows the game. The bigger issue isn't just that the chatbot messed up. It's that AI answers can look polished, confident, and ready for publication even when a basic check would catch something wrong.
That matters for anyone using AI at work. A model can draft, explain, summarize, and generate ideas quickly. It can also miss context that a specialist would treat as obvious. The Messi ad is small and public, but it points to a bigger operational question: how do you use AI without treating fluent output as verified output?
This article breaks down what happened, why the error has business consequences, and how teams can set up practical quality checks for AI-generated work.
What went wrong in the Messi chess ad?
Messi's Instagram post showed ChatGPT teaching him an opening called "GOAT Horns," a playful nod to his status as one of football's greatest. The ad drew serious attention - according to the reporting, it pulled in about 1.9 million likes and 19,600 comments in roughly a day.
The visual issue is straightforward. In a standard chess setup, each queen starts on a square of its own color, right next to its king. In the ad's version, the king and queen on each side look reversed. That's not a tiny cosmetic slip: it changes the starting position of both the king and the queen, so any opening advice has to be judged against the board that's actually shown.
The opening and the board are separate issues
The reported "GOAT Horns" sequence starts with 1.e4 a6 2.d4 c6. Opening moves aren't automatically good or bad on their own. Their value depends on the exact position, how the opponent responds, the player's level, and the plan that follows.
What chess commentators flagged is that, from the incorrectly arranged board in the ad, the suggested moves can lead to a rapid forced checkmate by move four. From a correctly set-up board, those same moves don't produce that forced mate. Same move list, different results - the board setup changes everything.
It's worth being precise here. This isn't simply "ChatGPT recommended a bad opening." A player could choose a weird or strategically risky opening for plenty of reasons. The sharper criticism is that the ad pairs an apparent setup error with advice whose outcome depends on that exact setup. A chess lesson has to get both the position and the explanation right.
Decrypt's report on the ad also notes that the chess community had complained about an earlier OpenAI advertisement where a black queen was misplaced. When the same kind of mistake shows up more than once, it suggests that the process for visual and domain-specific review may not have been consistent across campaigns.
The ad is a production, not just a model response
It's tempting to write this off as "the AI made an ad mistake." That might be too neat. A public campaign goes through a chain of steps - prompting, generation, design, editing, approvals, and publication. The available information doesn't pin down exactly who or what introduced the board error.
And that uncertainty is important. This doesn't prove ChatGPT alone created the incorrect board, and it doesn't prove the whole campaign was automated end to end. What we can say is simpler: the final published asset contained an error that a chess-aware review could have caught.
If a company is using AI in production, the responsibility isn't only on the model. It's also on the workflow. The practical question is not just, "Why did the model get this wrong?" It's also, "How did the wrong version make it through review and ship?"
Why a small AI error can become a brand problem
The board mistake is low stakes in a direct sense - it's an ad, not medical advice or a financial recommendation. But it's also highly visible. Messi has more than 500 million Instagram followers, and the campaign presents ChatGPT as a capable teacher. That makes a minor factual error feel like a test of the product's promise.
A user doesn't judge an AI tool only by what's written in documentation. Trust gets built through repeated experiences: does it answer accurately, does it flag uncertainty, does it notice when a request needs context? A visible mistake can tilt those perceptions, even if the model performs well on lots of other tasks.
The trust gap is between fluency and verification
Language models are good at producing text that sounds settled. That's useful for drafting, explaining, and generating options. It's also how an unverified answer can feel more reliable than it really is.
Chess makes the problem easier to spot than most fields. The board is rule-based and compact. A misplaced queen is immediately visible, and the line can be checked move by move. A lot of business work isn't that transparent. A legal summary can quietly omit a jurisdiction-specific exception. A product comparison can cite outdated specs. A spreadsheet formula might look fine on the sample row and still fail at the edges.
And the risk isn't limited to wrong facts. AI output can also be mismatched to its audience, inconsistent with what a company stands for, or technically correct but operationally harmful. In real projects, that last bucket often creates more work than a plainly incorrect answer. The content passes a quick check, gets embedded in a process, and only later fails under real conditions.
Brand exposure changes the cost of an error
When content is widely seen, preventable mistakes get expensive. A private brainstorming note can be corrected quietly. An ad starring a global athlete can spread before the company has much time to respond.
That doesn't mean brands should avoid AI-generated content. It means review effort has to match exposure and consequence. A useful way to think about risk is:
- Reach: How many people might see or reuse the output?
- Impact: What happens if it's wrong or misleading?
- Detectability: How easy is it for someone to catch the issue?
- Correction cost: Can you fix it after publication, or will it live on in downstream materials?
On a chessboard, direct harm may be low, but detectability is high. That combination makes the missed check especially preventable. In regulated or safety-critical work, the impact score rises fast - and the review needs to be more formal.
What the incident says about AI reliability
The Messi ad doesn't show AI is useless at chess, and it doesn't prove how the campaign's content was created. It does highlight something practical: AI capability varies by task, and confidence isn't the same thing as correctness.
A general-purpose model can explain chess concepts, suggest candidate openings, and help a beginner understand common plans. But it isn't the same as a dedicated chess engine. Tools like Stockfish calculate positions using chess-specific search and evaluation. A language model is built to generate likely responses from patterns in data; it may not reliably keep a legal board state across a sequence of moves.
A good way to frame it is like this: an assistant can help you reason about a codebase, but tests and static analysis are what actually check behavior. In strong workflows, those tools complement each other, rather than competing.
Match the tool to the failure mode
Before using an AI tool, figure out what kind of mistake would matter. If the task needs current facts, check whether it can access up-to-date sources. If it involves arithmetic, verify the math. If it requires following a formal ruleset, test against that ruleset. If it depends on visuals, review the image in the size and format where it will actually appear.
For chess advice, that means confirming the board position, entering the moves into a chess interface or analysis engine, and having a chess-competent reviewer judge whether the explanation fits the intended player. For an ad, the final creative still needs a basic visual and factual check before publication.
The same idea holds in other domains:
- A code assistant can draft a function; tests should verify expected behavior and edge cases.
- A research assistant can summarize a document; someone should verify the sources and any consequential quotes.
- A customer-support model can draft an answer; policy rules should decide what it's allowed to send.
- A data assistant can describe a trend; an analyst should confirm the query, definitions, and date range.
In short: choose the verification around how the work can fail, not around the novelty of using AI.
Context is part of the answer
There's also a smaller product-design question underneath the opening: what does "an opening that matched my style" actually mean? Messi's public identity makes "GOAT Horns" an obvious branding choice, but personalization in a name isn't the same as personalization in the instruction.
A useful chess lesson would spell out what the player wants - something easy to learn, an aggressive style, a compact repertoire, or a line that fits their current level. Without that context, the model can still produce something fun, but it may be weak as actual teaching. That trade-off is familiar in AI products: personalization can feel relevant, but the experience still has to solve the underlying task.
A practical quality-control process for AI content
AI quality assurance doesn't have to turn into a slow committee. The goal is to apply checks where they prevent meaningful risk, not to scrutinize every sentence with the same intensity. For everyday internal use, a lightweight process may be enough. For public, regulated, or high-impact output, add specialist review and trackable approvals.
1. Classify the output before generating it
Decide whether the output is exploratory, internal, customer-facing, or consequential. Brainstorming can tolerate more uncertainty than a public claim. Anything affecting money, health, legal status, safety, or access to a service needs stricter controls.
This classification should also determine what the model is allowed to do, what sources it can use, and who must approve the result. If the team can't explain the risk level, they probably haven't defined the use case clearly enough.
2. Separate generation from verification
Don't treat one model response as both the draft and the proof. Use an independent check where possible: a trusted primary source, a test suite, a domain-specific tool, or a human reviewer with relevant expertise.
For the chess ad, independent verification means checking the board and moves using a legal chess position - rather than asking the same chatbot whether it was right earlier. For a marketing statistic, it means tracing the claim to its source and confirming the date and exact wording.
3. Check the artifact people will actually see
Review what ships, not just the prompt or an intermediate draft. Errors can creep in during editing, image generation, layout, localization, or export. A solid text brief doesn't guarantee the final visual is correct.
A pre-publication checklist can be simple:
- Are names, dates, numbers, and claims supported?
- Does the visual match the written explanation?
- Does the output follow the relevant rules or product constraints?
- Is uncertainty represented honestly?
- Is the content appropriate for the audience and channel?
- Is there a clear owner who can correct it if it is wrong?
4. Scale review with risk and repetition
Checking something once is doable. Checking it 50 times can become a process problem. If a team repeatedly generates the same kind of content, turn review into a reusable control: templates, automated validation, approved source lists, or specialist sign-off for defined cases.
Automation helps when the check is objective and repeatable. It helps less when the key judgment depends on nuance, audience, or ambiguous context. In those situations, use automation to flag likely issues and reserve human time for decisions that actually need it.
5. Measure failures, not just speed
A workflow that produces content faster isn't automatically better if it increases rework, corrections, or customer confusion. Track what happens after deployment: factual corrections, rejected drafts, escalation rates, user complaints, and time spent on review.
These measures answer the business question that matters: is AI improving the whole system, or just shifting work from drafting to cleanup? The best implementation isn't the one with the most AI in it. It's the one that improves outcomes at an acceptable cost.
Conclusion: use AI, but keep the checks
The Messi chess ad sticks because the mistake is visible and the rules are clear. But the lesson goes beyond chess. AI can produce convincing work without reliably validating every detail inside it. Once that work reaches customers, the responsibility still sits with the people and systems that approve and publish it.
Treat AI as a capable part of a workflow, not as the workflow's quality guarantee. Define the risk, use the right verification method, and review the final artifact. If your team already uses AI in customer-facing work, start by auditing one high-visibility use case and documenting how its claims and outputs are checked. It's a more useful next step than trusting every answer - or banning the tool outright.