The forty rules

Forty rules, each with a threshold. They are mechanical for a reason: a rule that depends on taste cannot be reviewed, automated or argued with.

Read the rule, then check whether your code passes. When in doubt, choose the more restrictive option — that is the tie-breaker the philosophy prescribes.

The primary metric

Cyclomatic complexity ≤ 5 per method. This is the main instrument, not a decoration. It counts the independent paths a reader must hold in their head at once: every if, every loop, every boolean operator adds one.

A method at 6 is rejected, even if it is short and beautifully indented. The other rules exist to keep this number low — guard clauses remove branches, extraction moves them into names, polymorphism replaces switch.

All forty

The rule that is most often misread

Rule 25 forbids getters, setters and public properties. The usual mistake is to delete the getter and make the field public — which is worse, because now the invariant has no guardian at all.

The point is not visibility. It is ownership: the object must be the one that operates on its own attributes. Asking for state and changing it outside is procedural programming with classes.

final class Account
{
    public int $balance = 0;
}

$account->balance = $account->balance - 500;

final class Account
{
    private function __construct(private Money $balance) {}

    public function withdraw(Money $amount): self
    {
        if ($this->balance->isLessThan($amount)) {
            throw new InsufficientFunds($amount);
        }

        return new self($this->balance->subtract($amount));
    }
}

$account = $account->withdraw(Money::fromCents(500));

Both wrong examples below are equivalent: one exposes the field, the other exposes the field through methods. Neither protects the balance.

public sealed class Account
{
    public decimal Balance { get; set; }
}

account.Balance -= 500m;

public final class Account {
    private long balance;

    public long getBalance() { return balance; }
    public void setBalance(long balance) { this.balance = balance; }
}

account.setBalance(account.getBalance() - 500);

export class Account {
  public balance = 0;
}

account.balance -= 500;

export class Account {
  private constructor(private readonly balance: Money) {}

  withdraw(amount: Money): Account {
    if (this.balance.isLessThan(amount)) {
      throw new InsufficientFunds(amount);
    }

    return new Account(this.balance.subtract(amount));
  }
}

The rule that is most often ignored

Rule 9 — at most two instance variables. Three fields usually mean three responsibilities sharing a constructor, or one unnamed concept.

// Three instance variables: the concept has no name yet.
final class Service
{
    public function __construct(
        private ServiceName $name,
        private ServiceHost $host,
        private ServicePort $port,
    ) {}
}

// The concept is an endpoint. Name it, and the class drops to two fields.
final class Service
{
    private function __construct(
        private ServiceName $name,
        private Endpoint $endpoint,
    ) {}
}

The second version is not shorter by accident. Endpoint is the name the codebase was missing, and it is now the place where host and port validate each other.

Rules that change a signature

// Failures are values, not nulls.
final class WithdrawMoney
{
    public function __invoke(AccountId $id, Money $amount): Result
    {
        $account = $this->accounts->find($id);

        return $account->canWithdraw($amount)
            ? Result::success($account->withdraw($amount))
            : Result::failure(new InsufficientFunds($amount));
    }
}

Measuring the primary metric

Set the threshold in the pipeline, not in a wiki. A metric that is only visible in review is already dead.

Applying this to an existing codebase

1. Turn on the complexity check in report mode and count violations.
2. Pick the worst file, extract until the top method is below 5.
3. Lock that file with a baseline: it may not get worse.
4. Repeat weekly. The baseline shrinks or the number of violations freezes — both are progress.