Overview

In the high-stakes world of AAA game development, few milestones are as revealing—and as grueling—as the playtesting phase. Recently, Naoki Hamaguchi, co-director of the much-anticipated Final Fantasy VII Remake Part 3, disclosed that he has already completed the game over 40 times from start to finish, despite the public having seen almost no official footage or details. This extraordinary commitment to iterative testing underscores a core truth: the difference between a good game and a great one often lies in countless hours of dedicated, systematic playthroughs.

This guide will walk you through the art of iterative playtesting as practiced by industry professionals. Whether you're an indie developer or part of a larger team, you'll learn how to structure multiple playthroughs, capture meaningful feedback, and avoid common pitfalls—all while keeping your team's morale and creative vision intact.

Prerequisites

Before diving into a rigorous playtesting regimen, ensure you have the following in place:

• A playable build of your game – It doesn't have to be final, but it must be stable enough to allow a complete run (or at least a significant portion). Hamaguchi's team likely had a near-complete vertical slice for Part 3.
• A structured feedback system – Use tools like spreadsheets, bug-tracking software (e.g., Jira, Trello), or custom forms to record observations per playthrough.
• Clear objectives for each playthrough – Are you testing balance? Pacing? Narrative coherence? Technical stability? Define this beforehand.
• A dedicated tester (or team) committed to multiple runs – Ideally, one person should run the game repeatedly to build deep familiarity, just as Hamaguchi did.
• Version control and build management – Each playthrough should be based on a known build; track changes meticulously.

Step-by-Step Instructions

Step 1: Define Your Testing Scope and Goals

Before the first playthrough, ask: What do we need to learn? For FFVII Remake Part 3, Hamaguchi’s 40+ runs likely spanned multiple goals across different sessions. Break your own testing into phases:

• Playthroughs 1–5: Focus on game-breaking bugs, crashes, and progression blockers. Run the critical path only.
• Playthroughs 6–15: Evaluate combat balance, resource economy, and difficulty curves. Vary play styles (e.g., speedrunner vs. completionist).
• Playthroughs 16–30: Assess narrative pacing, dialogue triggers, and emotional beats. Play with different choices and side quests.
• Playthroughs 31–40+: Polish and fine-tune. Check UI/UX, minor animations, audio synchronization, and localization.

Document these objectives clearly before each round.

Step 2: Establish a Consistent Testing Environment

Repeatability is key. Use the same hardware (or at least the same specifications) for every run. Record each session’s build version, date, and any external conditions (e.g., internet connectivity for online features). Hamaguchi’s team likely had a dedicated test rig mirroring the target console or PC spec.

Step 3: Conduct the First Playthrough – Fresh Eyes

The initial run should mimic a first-time player. Do not skip cutscenes, tutorials, or exploration. Take notes on:

• First impressions of the opening sequence.
• Moments of confusion or frustration.
• Any mechanic that feels unintuitive.

Example code (pseudocode for a note-taking helper):

// Pseudocode for a feedback logging tool
class PlaythroughLogger {
    constructor(buildVersion, testerName) {
        this.build = buildVersion;
        this.tester = testerName;
        this.log = [];
        this.startTime = Date.now();
    }

    logEvent(eventType, description) {
        this.log.push({
            timestamp: Date.now() - this.startTime,
            type: eventType, // 'bug', 'balance', 'pacing', 'polish'
            description: description
        });
    }

    exportToCSV() {
        // Convert log to CSV for easy analysis
    }
}

After the run, review the log immediately while details are fresh.

Step 4: Iterate – Adjust, Rebuild, and Replay

Based on feedback from steps 1–40, prioritize changes. For a large team like Square Enix, each playthrough likely triggered a new build. For smaller teams, batch feedback into weekly releases. The process:

1. Collect all issues from the playthrough.
2. Categorize by severity (critical, high, medium, low).
3. Implement fixes for the top 5–10 items.
4. Build a new version.
5. Replay the same segment or a full run to verify fixes didn't break other systems (regression testing).

Repeat until the game reaches the desired quality. Hamaguchi’s 40+ runs suggest a highly disciplined iteration cycle.

Step 5: Vary Your Approach – The 80/20 Rule

Not every playthrough needs to be a 100% completion. Use the Pareto principle: 80% of critical issues will be found in 20% of the game’s content. After the early runs, focus on:

• Speed runs – Identify sequence breaks or exploits.
• Completionist runs – Test side content, rewards, and overall pacing.
• Stress tests – Intentionally make suboptimal choices, break the intended order, or mash buttons rapidly.

By mixing play styles, you simulate the diverse player base.

Step 6: Document and Share Insights

Maintain a central repository of all playthrough findings. Use a living document that every team member can access. Include:

• Executive summary of each playthrough.
• Detailed bug list with reproduction steps.
• Annotated video clips of key moments.
• Trend analysis (e.g., “Pacing issues consistently appear in Chapter 3 across runs 10–20”).

Hamaguchi’s team likely held daily stand-ups to discuss findings and adjust priorities.

Common Mistakes

1. Skipping the First Playthrough “Because You Know the Game”

Even the co-director of FFVII Remake Part 3 forced himself to play through the entire game repeatedly—not just the parts he changed. The curse of knowledge blinds developers to issues that new players will inevitably face. Avoid the temptation to fast-forward or debug menus during the first few runs.

2. Ignoring “Boring” Parts

Many testers skip or rush through tutorials, menus, or transition screens. These are often the source of the most confusing UX issues. In Hamaguchi’s many runs, he likely scrutinized every loading screen, shop interface, and tutorial prompt.

3. Not Tracking Build Versions

Without meticulous version control, you’ll waste time reproducing bugs that were already fixed. Use a clear naming convention (e.g., v1.2.3-alpha) and always note which build was tested.

4. Overlooking Player Fatigue

Running the same game 40+ times can lead to tester burnout and decreased observation quality. Rotate testers or take short breaks between runs. Hamaguchi likely had a team of testers assisting, but his personal 40+ runs show dedication—still, he knew when to step away.

5. Treating All Feedback as Equal

Not every issue demands immediate action. Some are subjective (e.g., “the color palette feels off”) while others are objective blockers (e.g., “crash when entering northern area”). Prioritize with a severity matrix.

Summary

Naoki Hamaguchi’s revelation that he has completed Final Fantasy VII Remake Part 3 over 40 times isn’t just a fun fact—it's a glimpse into the rigorous iterative playtesting that defines AAA quality. By setting clear goals, maintaining a consistent testing environment, varying your play styles, and avoiding common pitfalls like the curse of knowledge or version mismanagement, you too can elevate your game’s polish. Start with one focused playthrough, then iterate. Remember: each run brings you closer to a player’s experience—and that is the ultimate benchmark.