┌─────────────────────────────────────────────────────────────┐
│  1. WRITE FAILING TEST                                       │
│     Claude writes a test that defines expected behavior      │
│     Test MUST fail initially (proves test is valid)          │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│  2. RUN TEST (Confirm Failure)                               │
│     Use mcp-unity to run the test                            │
│     If test passes → test was wrong, rewrite                 │
│     If test fails → proceed to implementation                │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│  3. WRITE IMPLEMENTATION                                     │
│     Claude writes minimal code to make test pass             │
│     Don't over-engineer, just pass the test                  │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│  4. RUN TEST (Check Pass)                                    │
│     If PASS → Feature complete, move to next test            │
│     If FAIL → Go to step 5                                   │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│  5. DEBUG WITH GEMINI                                        │
│     Send error + code to Gemini for analysis                 │
│     Gemini suggests fix                                      │
│     Claude applies fix → Return to step 4                    │
└─────────────────────────────────────────────────────────────┘

using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools;
using VeilBreakers.[Namespace];

public class [Feature]Tests
{
    [Test]
    public void [Feature]_[Scenario]_[ExpectedResult]()
    {
        // Arrange
        var sut = new [SystemUnderTest]();

        // Act
        var result = sut.[Method]([inputs]);

        // Assert
        Assert.AreEqual([expected], result);
    }
}

[Test]
public void PoisonEffect_ApplyToTarget_DealsDamageOverTime()
{
    // Arrange
    var target = CreateTestCombatant(maxHealth: 100);
    var poison = new PoisonEffect(damagePerSecond: 5, duration: 3);

    // Act
    poison.Apply(target);
    SimulateTime(3f); // Advance 3 seconds

    // Assert
    Assert.AreEqual(85, target.CurrentHealth); // 100 - (5 * 3)
}

public class PoisonEffect : StatusEffect
{
    private float _damagePerSecond;
    private float _elapsed;

    public PoisonEffect(float damagePerSecond, float duration)
    {
        _damagePerSecond = damagePerSecond;
        Duration = duration;
    }

    public override void Tick(float deltaTime)
    {
        _elapsed += deltaTime;
        if (_elapsed >= 1f)
        {
            Target.TakeDamage(_damagePerSecond);
            _elapsed -= 1f;
        }
    }
}

gemini -p "Test failed with error: [error]. Code: [code]. What's wrong?"