Introduction: Building Useful AI Features Requires More Than Choosing a Model
Artificial intelligence is becoming an important part of modern software development, but building a reliable AI-powered application involves more than connecting a product to a language model. Different tasks require different capabilities, and assigning each task to the right technology is essential for accuracy, performance, and usability.
A chess training platform presents an interesting engineering challenge. It must evaluate moves accurately, identify meaningful tactical opportunities, explain complex positions in understandable language, and respond quickly while players solve puzzles. A single AI system is not necessarily suited to all these responsibilities.
A practical solution combines three technologies: a traditional chess engine such as Stockfish, a large language model such as Claude, and an AI coding agent such as Claude Code. Each performs a distinct role within the application. Their coordination demonstrates how carefully designed architecture and validation can make AI features useful in a production environment.
1. Designing the Application Architecture: Connecting the Frontend, Backend, and Processing Services
A chess training application needs an architecture that supports interactive gameplay as well as computationally intensive background tasks. The frontend, backend, and processing services must work together without allowing one operation to affect the responsiveness of another.
The frontend can be developed using React and TypeScript, with Vite handling the development and build process. This layer provides the interactive chessboard, puzzle interface, hints, and other training features. TypeScript also helps maintain consistency when handling chess positions and API responses.
A Spring Boot application written in Java serves as the backend. It handles JSON API requests, coordinates application functionality, and connects the user interface with the processing services. Puzzle generation operates through a separate Java service, keeping engine-intensive operations away from the main application request flow.
For a smaller application, JSON and JSON Lines files can provide a practical storage solution. They are readable, relatively straightforward to inspect, and easier to compare during development. Nightly backups to Amazon S3 provide an additional recovery layer without requiring a separate database server.
The infrastructure can remain equally focused. One EC2 instance can host the application, with nginx managing incoming traffic and systemd keeping services running. GitHub Actions can automate deployment whenever approved changes are merged into the main branch.
This approach demonstrates an important architectural principle: infrastructure should reflect actual requirements. A distributed system with multiple database services is not automatically better if a simpler setup can handle the application's workload reliably.
2. Using a Chess Engine to Generate Puzzles from Real Game Data
Personalized chess puzzle generation begins with the games players have already completed. After connecting a Chess.com or Lichess account, a background process retrieves available game records and examines the positions in which the player may have missed a tactical opportunity.
Stockfish performs the central analytical work. Unlike a language model, a chess engine evaluates positions through systematic move calculation. It compares candidate moves, examines variations, and identifies positions where one move provides a significantly better result than the alternatives.
Not every interesting position becomes a puzzle. The selection process needs clear conditions. A candidate should have an identifiable best move, weaker alternatives, and a continuation that maintains the winning advantage for several moves. These requirements help prevent unclear or misleading exercises.
The engine can analyse positions at a fixed search depth, creating a consistent basis for comparison. Its evaluations help identify blunders, missed wins, and tactical opportunities that might otherwise remain unnoticed during ordinary post-game review.
Running a separate Stockfish process for every position would create unnecessary overhead. Instead, long-lived UCI processes can be maintained in a pool and reused for multiple analysis tasks. This reduces repeated startup costs and makes CPU usage easier to control.
Background puzzle generation must also remain separate from live puzzle evaluation. Generating exercises from thousands of positions can be computationally demanding, while an active player expects immediate feedback. Separating these workloads helps protect the interactive experience.
3. Giving Engine Analysis a Human Explanation Through a Language Model
A chess engine can identify the strongest move and calculate a winning variation, but numerical evaluations alone do not necessarily explain why a move works. Players need to understand the tactical idea, the threats involved, and why another move that appears equally strong is less effective.
TacticsChess is built around a simple promise to the player: tactics from my own games, turned into understandable training exercises rather than raw engine lines. The platform follows the principle behind its message, "You keep missing the same tactics. Here they are, explained." It combines master-game positions with missed opportunities from linked Chess.com and Lichess games, converting them into interactive puzzles with written coaching.
However, the language model does not need to independently analyse the chessboard. Java code first prepares structured information from the engine's findings. This can include the approved solution line, pieces being attacked or defended, the tactical theme, and the move originally played by the user.
Claude receives these verified facts and uses them to produce a short explanation in plain English. The result can describe why a particular move creates a threat, how a piece becomes vulnerable, or why an apparently reasonable alternative fails.
This separation is important. Stockfish remains responsible for determining move quality, while the language model focuses on communicating the established findings. It makes the coaching more accessible without giving a text-generation system authority over chess calculations.
4. Building Guard Rails: Validating AI Explanations Before They Reach Users
Fluent AI-generated text is not automatically accurate. In chess instruction, an explanation that describes an illegal move, invents a tactical threat, or overlooks the required solution can teach the wrong lesson. Generated notes therefore need to pass validation before reaching players.
A validation process can compare the model's response with the structured information supplied during generation. Important checks include:
- Approved move verification: The validator checks whether moves mentioned in the explanation belong to the permitted solution variations. This helps prevent the model from introducing unsupported moves or describing lines that the engine did not establish.
- Required solution checks: An explanation must include the essential first move when the task requires it. If that move is missing, the response can be rejected even if the remaining text sounds convincing.
- Unsupported claim detection: Claims about attacks, threats, and positional advantages must agree with the supplied chess facts. Explanations that go beyond the available evidence should not be accepted.
- Controlled regeneration: When a note fails validation, the system can request another version. If repeated attempts fail, the puzzle falls back to a short note built only from the verified facts, and a position judged not worth teaching is held back rather than shown with unreliable coaching.
Approved explanations and initial hints can be generated in batches and cached. This avoids repeatedly calling the language model whenever a player opens the same puzzle. Later hint stages and wrong-move feedback can also be produced through deterministic code when the required information is already available from engine analysis.
The wider lesson is that language models should handle language generation, while verifiable decisions should remain with systems that can apply consistent rules.
5. Using an AI Coding Agent Without Removing Human Engineering Oversight
An AI coding agent can also support the development and maintenance of a production application. Claude Code, for example, can inspect project files, understand existing implementation patterns, modify code, and run development commands.
A controlled workflow begins with a human describing the requested feature. The agent examines the relevant files, asks clarification questions when necessary, and implements the change on a separate branch. It can then run automated tests, build the frontend, and check the interface through a headless browser, including at mobile screen sizes.
The resulting changes are submitted through a pull request. Human review remains essential because passing tests does not guarantee that a feature meets product requirements or behaves correctly in every real-world situation.
After approval, merging into the main branch triggers deployment through GitHub Actions. The updated application can then be checked to confirm that the expected changes are live.
A Markdown knowledge base makes this workflow more consistent. Architecture notes, data-flow explanations, repository information, and important file references help the coding agent understand the project. A separate pitfalls document can record operational mistakes and precautions that should be checked before risky actions.
The coding agent becomes more useful when it has reliable project context, but the human developer retains responsibility for reviewing and approving production changes.
6. Operating and Improving the Product Through Automated Monitoring and Remote Workflows
Launching an application is only one part of maintaining it. Services can become unavailable, background jobs can stall, and configuration changes can introduce unexpected problems. Automated monitoring helps identify these issues before they remain unnoticed for long periods.
Several practical workflows can support ongoing operations:
- Service monitoring: Watcher scripts can check TLS configuration, CORS behaviour for approved origins, and API availability. When a check fails, an email alert gives the owner an opportunity to investigate.
- Background job reporting: Puzzle-generation processes can report failures, unexpected delays, or stalled tasks. This makes processing problems visible instead of allowing jobs to stop silently.
- AI-assisted investigation: A coding agent can inspect application logs and stored data to identify possible causes. Documenting findings before making changes helps keep troubleshooting controlled and traceable.
- Remote development sessions: A development session running on the server through a terminal multiplexer can be accessed remotely from a phone. The owner can review progress, inspect screenshots, answer questions, and approve work without remaining at a computer.
- Automated content production: Browser recordings of real puzzle sessions can be used to create short featured-puzzle videos with text-to-speech narration. Social media drafts can also be prepared by the agent and reviewed before publication.
- User activity analysis: Application logs and activity files can answer practical questions about engagement and feature usage. This can provide useful operational insight without requiring a complex analytics dashboard for every investigation.
These workflows reduce repetitive tasks, but automation does not remove the need for oversight. Alerts require interpretation, generated content needs review, and production changes should remain subject to human approval.
Conclusion: Reliable AI Applications Depend on Clear Responsibilities and Strong Validation
A production chess training platform demonstrates how several AI technologies can work together without competing for the same responsibilities. Stockfish evaluates moves and identifies tactical opportunities, a language model turns verified findings into understandable coaching, and an AI coding agent assists with development and maintenance.
The reliability of this approach comes from the boundaries between these systems. Structured facts guide generated explanations, validators reject unsupported claims, caching controls repeated generation, and background processing protects the live experience. Automated monitoring and human review provide further safeguards throughout the application's lifecycle.
Practical AI engineering is not about automating every decision or using the largest possible model. It is about selecting the right tool for each task, understanding its limitations, and designing a system in which accuracy and user experience remain central.
