┌─────────────────────────────────────────┐
    │                                         │
    ▼                                         │
┌───────┐      ┌───────┐      ┌───────────┐  │
│  RED  │ ───▶ │ GREEN │ ───▶ │ REFACTOR  │──┘
└───────┘      └───────┘      └───────────┘
 Write a        Write the      Improve the
 failing        minimum        code while
 test           code to        keeping tests
                pass           green

// RED: Test what we want, not what we have
describe('AdvertisementBot', () => {
  it('should send advertisement to specified channel', async () => {
    const bot = AdvertisementBot.create({
      name: 'TestBot',
      ownerId: 'user-123',
    });

    const result = bot.sendAdvertisement({
      channel: 'discord',
      message: 'Check out our marketplace!',
    });

    expect(result.isSuccess()).toBe(true);
    expect(bot.lastActivity).toBeDefined();
  });
});

// GREEN: Minimum code to pass
class AdvertisementBot {
  private _lastActivity?: Date;

  get lastActivity() {
    return this._lastActivity;
  }

  static create(props: { name: string; ownerId: string }) {
    return new AdvertisementBot();
  }

  sendAdvertisement(props: { channel: string; message: string }) {
    this._lastActivity = new Date();
    return { isSuccess: () => true };
  }
}

// REFACTOR: Proper domain model
class AdvertisementBot extends AggregateRoot<BotId> {
  private readonly name: BotName;
  private readonly ownerId: UserId;
  private lastActivity?: Timestamp;

  private constructor(props: AdvertisementBotProps) {
    super(props.id);
    this.name = props.name;
    this.ownerId = props.ownerId;
  }

  static create(props: CreateBotProps): Result<AdvertisementBot> {
    const nameResult = BotName.create(props.name);
    if (nameResult.isFailure()) {
      return Result.fail(nameResult.error);
    }

    return Result.ok(new AdvertisementBot({
      id: BotId.generate(),
      name: nameResult.value,
      ownerId: UserId.from(props.ownerId),
    }));
  }

  sendAdvertisement(command: SendAdvertisementCommand): Result<void> {
    // Validate channel
    const channelResult = Channel.create(command.channel);
    if (channelResult.isFailure()) {
      return Result.fail(channelResult.error);
    }

    // Record activity
    this.lastActivity = Timestamp.now();

    // Raise domain event
    this.addDomainEvent(new AdvertisementSent({
      botId: this.id,
      channel: channelResult.value,
      sentAt: this.lastActivity,
    }));

    return Result.ok();
  }
}

// PATTERN: should_[expected]_when_[condition]
'should reject registration when name is empty'
'should calculate discount when order exceeds threshold'
'should emit event when status changes'

// PATTERN: [method]_[scenario]_[expected]
'register_withEmptyName_throwsValidationError'
'calculateDiscount_orderAboveThreshold_applies10Percent'

// PATTERN: Given_When_Then (BDD style)
'given valid bot credentials, when registering, then bot is created'

it('should calculate total with tax', () => {
  // ARRANGE: Set up the test scenario
  const order = Order.create({
    items: [{ price: 100, quantity: 2 }],
    taxRate: 0.1,
  });

  // ACT: Execute the behavior under test
  const total = order.calculateTotal();

  // ASSERT: Verify the expected outcome
  expect(total).toBe(220); // 200 + 10% tax
});

BDD (Outer Loop)              TDD (Inner Loop)
┌────────────────┐            ┌────────────────┐
│ Feature file   │ ──────────▶│ Unit tests     │
│ (Gherkin)      │            │ (TDD cycle)    │
│                │            │                │
│ Given/When/Then│ ──────────▶│ RED            │
│                │            │ GREEN          │
│                │            │ REFACTOR       │
└────────────────┘            └────────────────┘

@bdd-writer → Creates BDD scenarios (acceptance tests)
     ↓
@code-writer → Implements using TDD (unit tests)
     ↓
@bdd-runner → Verifies BDD scenarios pass

Starting new feature?
├─ Yes → Write failing acceptance test (BDD)
│        └─ Then TDD the implementation
│
└─ No, fixing a bug?
   ├─ Yes → Write failing test that reproduces bug
   │        └─ Then fix using TDD (test fails → passes)
   │
   └─ No, refactoring?
      └─ Ensure tests exist
         └─ If not, write characterization tests first
            └─ Then refactor with safety net

1. Pick smallest behavior to implement
2. Write test that fails
3. Run test, see it fail (RED)
4. Write simplest code to pass
5. Run test, see it pass (GREEN)
6. Clean up code and tests
7. Run all tests (REFACTOR)
8. Repeat

src/
├── domain/bot/
│   └── AdvertisementBot.ts
└── __tests__/domain/bot/
    └── AdvertisementBot.test.ts