GOSU : Go Trainer

Your personal AI tutor for mastering the game of Go

Comment

Inspiration

"Go, once believed to be an uniquely human domain, underwent a tectonic shift in a single match."

In March 2016, the historic match between Lee Sedol 9p and AlphaGo declared to the world that the era of AI had arrived. Today, ten years later in July 2026—marked by the epic clash between Shin Jin-seo 9p and KataGo—the paradigm of Go has been completely rewritten.

The era of learning under legendary masters and inheriting traditional playing styles is over. Modern Go has evolved into a realm of "who can approximate the precision of AI most closely."

Rather than resisting this inevitable shift, we embrace it as an expansion of human wisdom. To help players transcend human limitations alongside the ultimate AI mentor and usher in a new era of training, we built GOSU: Go Trainer.

What it does

Product & Design

I believed the single biggest issue in Go game record (Kifu) study was the disconnect between "reading the commentary" and "placing the stones." When studying with printed books, learners constantly cycle between reading text, searching for move numbers, and placing physical stones. To unify this into a seamless experience, I designed Interactive Read-along Sync, where the board dynamically responds as the user reads through the explanation.

In the initial prototype, hovering over commentary or following specific sentences dynamically triggered stone placements and variation lines directly on the board. In the actual product, hovering over or focusing with keyboard on coordinates mentioned in the AI coach's response (such as R16 or C4) instantly highlights those positions on the board. This eliminates the cognitive friction of cross-referencing text and coordinates.

Furthermore, while win rates and score leads provided by Go AI engines are valuable, they often feel cold and daunting to beginners. To address this, I designed a conversational AI tutor that feels like a friendly, personal mentor. Rather than delivering raw metrics, the goal is to ease the isolation of self-study by explaining why a move is good or bad in clear, intuitive language.

Engineering

I focused on unifying playing, analysis, review, and AI coaching around a single game record. Users can play against KataGo on $9 \times 9$, $13 \times 13$, or $19 \times 19$ boards, viewing move recommendations, real-time win rates, and expected score leads before making a move. Post-game features include an interactive win-rate timeline for stepping through past positions, alongside exploratory branches that let users test alternative move sequences without altering the original game record. Games are automatically saved, supporting resume play, as well as SGF import and export.

The LLM Coach receives the current board state, game history, active rules, and KataGo analysis concurrently. Instead of sending generic prompts, we supply explicit tools and structured contracts representing the exact state and ground truth. Evaluated metrics within coach responses—such as win rates, score leads, coordinates, and move legality—are strictly validated against the current game state.

How we built it

Product & Design

While my engineer partner extracted engine data and built the analysis pipeline, my focus as the sole Product Planner and Designer was translating mechanical data into a warm, approachable user interface. Handling both planning and design enabled me to carry the core vision—a "friendly Go tutor"—consistently across layout, copy, typography, color palettes, and interactive elements.

The UI needed to accommodate the board, detailed commentaries, move candidates, real-time analysis charts, and coach dialogue simultaneously. To keep users from feeling overwhelmed, I established a clear visual hierarchy and refined the layout and typography down to the single pixel level so attention flows naturally.

To ensure text and the board feel intrinsically connected, I introduced micro-interactions that trigger immediate visual feedback on the board whenever users hover over text coordinates or strategic expressions.

Engineering

I applied Clean Architecture principles, specifically the Ports & Adapters pattern, to strictly decouple Go rules, game flow, KataGo execution, data storage, LLM providers, and the Electron UI layer.

A key example is our GameManager. As features expanded, this entry point grew to $\sim 2{,}000$ lines. I isolated it behind a compact $\sim 10$-line facade, splitting the internal logic into dedicated coordinators for game flow, AI responses, scoring, review, and storage. To prevent architectural drift, automated tests enforce facade size limits and ban reverse dependencies or direct coordinator-to-coordinator calls.

For the AI Coach, we defined provider-agnostic model ports instead of coupling logic to specific provider SDKs. Messages, streaming, tool calling, and structured outputs are governed by shared contracts, with provider differences handled by outward adapters. This avoided duplicating grounding and validation policies across different models.

To streamline KataGo setup, we divided binary acquisition, neural net preparation, GTP config generation, and process verification into standard step interfaces. Platform-specific workflows—like macOS Homebrew integration or Windows x64 installation paths—are isolated within adapters, allowing future platform additions without touching core game or UI logic.

We leveraged Codex as a long-running development partner for codebase exploration, scoped feature implementation, contract/regression test writing, and root-cause analysis. On local Git hooks, commits trigger Jest unit tests, TypeScript type checks, production builds, DB schema validations, KataGo smoke tests, and Playwright E2E suites. The separate Managed Luna relay runs under a strict $100\%$ code coverage threshold.

Challenges we ran into

Product & Design

The main design challenge was bridging the cognitive gap between AI text descriptions and physical board behavior. If users couldn't immediately map written explanations to coordinates on the board, their learning momentum was lost.

I spent significant effort establishing clear interaction rules to ensure the board and text sync smoothly—balancing coordinate highlighting, stone animations, and variation overlays so they complement rather than clash with one another.

Another challenge was filtering out signal from noise. Exposing every raw win-rate fluctuation and score margin computed by the engine proved counterproductive for learning. I carefully selected which data points matter most to user decision-making, trimming unnecessary visual clutter while emphasizing essential insights.

Engineering

Ensuring the AI produces accurate board analysis rather than just fluent text was a major hurdle. Citing previous game states as current, or swapping Black and White win rates, completely destroys user trust.

We solved this by binding every prompt to a strict game state digest and requiring answers to return explicit evidenceRefs. Metrics like win rates, point differences, recommended moves, and legal placements are automatically cross-checked against the current state; if evidence is insufficient, the system abstains from guessing. We built a $72$-scenario evaluation corpus across English and Korean to continuously test key response contracts.

KataGo environment setup also presented hidden edge cases. On macOS, our setup initially checked for Homebrew first, blocking users who already had KataGo installed manually. We refactored this logic to check for existing KataGo installations before checking Homebrew, locking the behavior in regression tests.

Finally, a single stone placement mutates memory board states, SQLite records, and the KataGo process concurrently. We serialized all mutations through a unified queue, implementing checkpoint rollbacks and engine replays on pre-save failures, while preserving saved moves in safe recovery states if post-save engine sync fails.

Accomplishments that we're proud of

Product & Design

Our proudest achievement is transforming traditional, rigid game record study into an interactive "read-along" experience. Instead of treating text and board as separate elements, we created a unified learning flow where the board actively responds as you read.

We also succeeded in giving cold engine analytics the warm, encouraging voice of a personal mentor. By unifying tone, information sequencing, and visual polish, we built a friendly AI companion that makes Go learning accessible and inviting for beginners.

Engineering

We successfully delivered a seamless desktop learning loop combining play, analysis, review, exploratory practice, and conversational coaching into one cohesive app. Users can jump to past moves via the timeline, experiment with alternate paths, and ask the AI Coach about specific positions—with response coordinates linking right back to the board.

We also prioritized exact Go rule compliance. We reviewed $144$ rules from the Korea Baduk Association and implemented executable tests covering all $143$ digitally enforceable cases. Full $300$-move games—including generation, state restoration, undos, and final counting—are comprehensively verified via end-to-end scenarios.

Lastly, establishing a developer harness—combining architectural boundaries, smoke tests, evaluation corpuses, and commit hooks—ensured agent-generated code is safely reviewed by humans without breaking existing functionality.

What we learned

Product & Design

We learned that even world-class analysis engines like KataGo offer little value if their outputs aren't translated into human-centered language and visuals. Advanced technology loses its impact without intuitive UX/UI to bridge the gap.

Handling both product planning and design reinforced the power of end-to-end alignment. Managing both roles allowed us to translate our core vision into every layout, sentence, micro-interaction, and visual detail without losing context.

Engineering

We learned that agent productivity relies heavily on environment design rather than raw model capability alone. Clear architectural boundaries, executable contracts, small atomic tasks, and automated commit hooks were essential for preventing regressions during long task runs.

Equally important was realizing that automated tests cannot replace product judgment. While agents accelerated implementation, determining what best serves a Go learner, prioritizing information, and ensuring explanations fit the true context of the game required human reflection and debate.

What's next for GOSU : Go Trainer

1. [Learning Experience] Dynamic Engine for Life & Death Tab

Transition the current static demo code into a fully functional product module seamlessly connected with live play and review screens.

  • Dynamic Answer Trees & Computer Responses: Move beyond single first-move validation to a dynamic engine where the computer plays defensive responses and validates entire tactical trees.

  • Game-based Problem Extraction: Automatically extract key turning points and mistakes detected by KataGo during post-game reviews, generating personalized Life & Death problems.

  • Bidirectional Deep Linking: Allow users to click "Open Original Game" within any Life & Death problem to jump straight to that exact move in their recorded game.

  • AI Coach Visual Guides: Replace simple correct/incorrect feedback with visual, step-by-step countermove demonstrations directly on the board.

  • Custom Problem Filtering: Enable real-time problem filtering by difficulty level (Beginner to Advanced) and board location (Corner, Side, Center).

2. [Learning Experience] Real Data Analytics Dashboard

Replace hardcoded demo data with a dynamic dashboard driven by stored SGF records and problem-solving history.

  • Dynamic Level Estimation: Calculate live user rank by combining recent $10$-game win rates, opponent AI difficulty, and accuracy across the last $20$ Life & Death problems.

  • Weakness & Pattern Visualization: Display performance cards showing accuracy by board region and highlighting recurring weaknesses in opening or tactical play.

  • Streak Tracking System: Track and display daily study streaks for completing games or solving tactical problems.

  • Interactive Chart Navigation: Allow users to click specific points on their skill progression chart to review representative games or problems from that period.

  • Advanced Analytics Expansion: Plan future expansions including Joseki database comparisons, custom move notes, and head-to-head comparisons between player moves and AI recommendations.

3. [AI Agent] Coach Performance Optimization Pipeline

Establish a Human-in-the-Loop (HITL) semi-automated improvement workflow to continually enhance explanation quality and rule compliance.

  • Inference & Benchmark Deployment: Deploy a managed GPT-5.6 Luna inference server and regularly benchmark board understanding, rule accuracy, recommendation consistency, and clarity using GPT-5.6 Sol alongside game datasets.

  • Failure Classification & Agent Proposals: Automatically categorize benchmark failures and prompt the agent to propose improvements to prompts, tool-use policies, and grounding validation rules.

  • Human Approval & Regression Testing: Ensure the agent cannot modify production directly; proposed updates are applied only after human review and passing regression tests against historical game records.

4. [Product Direction & Global Release]

  • Personalized Playstyle Trainer (Standalone Module): Analyze user tendencies (e.g., aggressive vs. territory-oriented) and offer tailored learning paths to develop their desired playstyle (a separate long-term direction from the Life & Death and Analytics tabs).

  • Global Release via Steam: Focus on polishing desktop performance, stabilizing installation and update flows, and refining engine packaging for a global Steam launch rather than adding new languages at this stage.

Built With

Share this project:

Updates