What Changes at 50+ Projects📋

// MegaCorp.Requirements/Features/OrderProcessingFeature.cs
// New AC added by the order-team:

/// <summary>
/// AC-9: Customer loyalty points are credited after successful order.
/// Points = floor(order total / 10). Credited within 5 seconds of payment capture.
/// </summary>
public abstract AcceptanceCriterionResult LoyaltyPointsCredited(
    OrderSummary order,
    CustomerId customer,
    int pointsEarned,
    TimeSpan elapsed);

Build started...

MegaCorp.Requirements → Build succeeded.
MegaCorp.SharedKernel → Build succeeded.

MegaCorp.Specifications →
  error REQ101: OrderProcessingFeature.LoyaltyPointsCredited has no matching
                specification method with [ForRequirement(typeof(OrderProcessingFeature),
                nameof(OrderProcessingFeature.LoyaltyPointsCredited))]
                → Add a method to a spec interface (e.g., IOrderProcessingSpec or a new
                  ILoyaltyIntegrationSpec) with the matching [ForRequirement] attribute.
  Build FAILED.

MegaCorp.OrderService →
  (skipped — depends on MegaCorp.Specifications which failed)

MegaCorp.OrderService.Tests →
  (skipped — depends on MegaCorp.OrderService which was skipped)

Build: 2 succeeded, 1 failed, 3 skipped.

// MegaCorp.Specifications/OrderProcessing/ILoyaltyIntegrationSpec.cs
namespace MegaCorp.Specifications.OrderProcessing;

using MegaCorp.Requirements.Features;
using MegaCorp.SharedKernel;

/// <summary>
/// Specification for loyalty point operations within order processing.
/// Implemented by: MegaCorp.UserService (loyalty is a user-domain concept).
/// </summary>
[ForRequirement(typeof(OrderProcessingFeature))]
public interface ILoyaltyIntegrationSpec
{
    [ForRequirement(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.LoyaltyPointsCredited))]
    Task<Result> CreditLoyaltyPoints(Order order, int points);
}

MegaCorp.Specifications → Build succeeded. (REQ101 resolved)

MegaCorp.OrderService →
  error CS0535: 'OrderProcessingService' does not implement interface member
                'IOrderProcessingSpec.ProcessOrder' — wait, that's already implemented.

  Actually, the build succeeds for OrderService because it doesn't implement
  ILoyaltyIntegrationSpec. But:

  error REQ200: ILoyaltyIntegrationSpec has no implementing class.
                → Create a class that implements ILoyaltyIntegrationSpec.
  Build FAILED.

// MegaCorp.UserService/LoyaltyPointService.cs
namespace MegaCorp.UserService;

using MegaCorp.Requirements.Features;
using MegaCorp.Specifications.OrderProcessing;
using MegaCorp.SharedKernel;

[ForRequirement(typeof(OrderProcessingFeature))]
public class LoyaltyPointService : ILoyaltyIntegrationSpec
{
    private readonly ILoyaltyRepository _repo;

    public LoyaltyPointService(ILoyaltyRepository repo) => _repo = repo;

    [ForRequirement(typeof(OrderProcessingFeature),
        nameof(OrderProcessingFeature.LoyaltyPointsCredited))]
    public async Task<Result> CreditLoyaltyPoints(Order order, int points)
    {
        if (points <= 0)
            return Result.Success(); // No points to credit

        await _repo.AddPoints(order.Customer, points, $"Order {order.Id.Value}");
        return Result.Success();
    }
}

// MegaCorp.OrderService/OrderProcessingService.cs — updated constructor
public OrderProcessingService(
    IInventoryIntegrationSpec inventory,
    IPaymentIntegrationSpec payment,
    INotificationIntegrationSpec notification,
    IAuditIntegrationSpec audit,
    ILoyaltyIntegrationSpec loyalty,  // ← NEW
    IOrderRepository orderRepo)
{
    // ...
    _loyalty = loyalty;
}

// In ProcessOrder, after payment capture:
// AC-9: Credit loyalty points
var points = (int)Math.Floor(order.Total.Amount / 10m);
await _loyalty.CreditLoyaltyPoints(order, points);

// MegaCorp.Web/Program.cs
builder.Services.AddScoped<ILoyaltyIntegrationSpec, LoyaltyPointService>();

// MegaCorp.OrderService.Tests/OrderProcessingTests.cs
[Test]
[Verifies(typeof(OrderProcessingFeature),
    nameof(OrderProcessingFeature.LoyaltyPointsCredited))]
public async Task Loyalty_points_credited_after_order()
{
    _stripeClient.Configure(succeed: true);
    var command = CreateOrderCommand(items: new[] { ("SKU-001", 5) },
        unitPrice: 20.00m); // Total: 100 → 10 points

    var result = await _service.ProcessOrder(command);

    Assert.That(result.IsSuccess, Is.True);
    Assert.That(_loyaltyRepo.GetPoints(command.CustomerId), Is.EqualTo(10));
}

[Test]
[Verifies(typeof(OrderProcessingFeature),
    nameof(OrderProcessingFeature.LoyaltyPointsCredited))]
public async Task No_loyalty_points_for_small_order()
{
    _stripeClient.Configure(succeed: true);
    var command = CreateOrderCommand(items: new[] { ("SKU-001", 1) },
        unitPrice: 5.00m); // Total: 5 → 0 points

    var result = await _service.ProcessOrder(command);

    Assert.That(result.IsSuccess, Is.True);
    Assert.That(_loyaltyRepo.GetPoints(command.CustomerId), Is.EqualTo(0));
}

MegaCorp.Requirements     → Build succeeded.
MegaCorp.SharedKernel     → Build succeeded.
MegaCorp.Specifications   → Build succeeded. info REQ103: OrderProcessingFeature — 9/9 ACs specified
MegaCorp.UserService      → Build succeeded. info REQ203: ILoyaltyIntegrationSpec — implemented
MegaCorp.OrderService     → Build succeeded.
MegaCorp.OrderService.Tests → Build succeeded. info REQ303: OrderProcessingFeature — 9/9 ACs tested

Build: 6 succeeded, 0 failed.

OrderProcessingFeature (37 references across 12 files in 8 projects)
│
├── MegaCorp.Specifications/OrderProcessing/IOrderProcessingSpec.cs
│   ├── [ForRequirement(typeof(OrderProcessingFeature))] on interface
│   ├── [ForRequirement(..., nameof(...OrderTotalMustBePositive))] on method
│   ├── [ForRequirement(..., nameof(...BulkOrderDiscountApplied))] on method
│   └── [ForRequirement(..., nameof(...OrderPersistedWithFullDetail))] on method
│
├── MegaCorp.Specifications/OrderProcessing/IInventoryIntegrationSpec.cs
│   ├── [ForRequirement(typeof(OrderProcessingFeature))] on interface
│   ├── [ForRequirement(..., nameof(...InventoryReservedBeforePayment))] on method
│   └── [ForRequirement(..., nameof(...FailedPaymentReleasesInventory))] on method
│
├── MegaCorp.Specifications/OrderProcessing/IPaymentIntegrationSpec.cs
│   ├── [ForRequirement(typeof(OrderProcessingFeature))] on interface
│   └── [ForRequirement(..., nameof(...PaymentCapturedAfterReservation))] on method
│
├── MegaCorp.Specifications/OrderProcessing/INotificationIntegrationSpec.cs
│   └── [ForRequirement(..., nameof(...ConfirmationSentAfterPayment))] on method
│
├── MegaCorp.Specifications/OrderProcessing/IAuditIntegrationSpec.cs
│   └── [ForRequirement(..., nameof(...AllOperationsAudited))] on method
│
├── MegaCorp.Specifications/OrderProcessing/ILoyaltyIntegrationSpec.cs
│   └── [ForRequirement(..., nameof(...LoyaltyPointsCredited))] on method
│
├── MegaCorp.OrderService/OrderProcessingService.cs
│   └── [ForRequirement(typeof(OrderProcessingFeature))] on class
│
├── MegaCorp.InventoryService/InventoryReservationService.cs
│   └── [ForRequirement(typeof(OrderProcessingFeature))] on class
│
├── MegaCorp.PaymentGateway/StripePaymentService.cs
│   └── [ForRequirement(typeof(OrderProcessingFeature))] on class
│
├── MegaCorp.NotificationService/OrderNotificationService.cs
│   └── [ForRequirement(typeof(OrderProcessingFeature))] on class
│
├── MegaCorp.UserService/LoyaltyPointService.cs
│   └── [ForRequirement(typeof(OrderProcessingFeature))] on class
│
├── MegaCorp.Web/Controllers/OrderController.cs
│   └── [ForRequirement(typeof(OrderProcessingFeature))] on controller + methods
│
└── MegaCorp.OrderService.Tests/OrderProcessingTests.cs
    ├── [TestsFor(typeof(OrderProcessingFeature))] on class
    ├── [Verifies(..., nameof(...OrderTotalMustBePositive))] × 4 tests
    ├── [Verifies(..., nameof(...InventoryReservedBeforePayment))] × 2 tests
    ├── [Verifies(..., nameof(...PaymentCapturedAfterReservation))] × 2 tests
    ├── [Verifies(..., nameof(...ConfirmationSentAfterPayment))] × 1 test
    ├── [Verifies(..., nameof(...AllOperationsAudited))] × 1 test
    ├── [Verifies(..., nameof(...FailedPaymentReleasesInventory))] × 1 test
    ├── [Verifies(..., nameof(...BulkOrderDiscountApplied))] × 2 tests
    ├── [Verifies(..., nameof(...OrderPersistedWithFullDetail))] × 1 test
    └── [Verifies(..., nameof(...LoyaltyPointsCredited))] × 2 tests

// The `Owner` property on each Feature type declares ownership:
public abstract record OrderProcessingFeature : Feature<ECommerceEpic>
{
    public override string Owner => "order-team";
    // ...
}

public abstract record PaymentProcessingFeature : Feature<ECommerceEpic>
{
    public override string Owner => "payment-team";
    // ...
}

public abstract record InventoryManagementFeature : Feature<ECommerceEpic>
{
    public override string Owner => "inventory-team";
    // ...
}

Team Ownership Report
═══════════════════════════════════════════════════════

order-team:
  Features: OrderProcessingFeature (9 ACs)
  Spec implementations: OrderProcessingService
  Spec dependencies:
    IInventoryIntegrationSpec → inventory-team
    IPaymentIntegrationSpec → payment-team
    INotificationIntegrationSpec → cx-team
    IAuditIntegrationSpec → compliance-team
    ILoyaltyIntegrationSpec → user-team

payment-team:
  Features: PaymentProcessingFeature (5 ACs)
  Spec implementations: StripePaymentService
  Also implements for: OrderProcessingFeature (IPaymentIntegrationSpec)

inventory-team:
  Features: InventoryManagementFeature (4 ACs)
  Spec implementations: InventoryReservationService
  Also implements for: OrderProcessingFeature (IInventoryIntegrationSpec)

user-team:
  Features: UserManagementFeature (6 ACs)
  Spec implementations: UserService, LoyaltyPointService
  Also implements for: OrderProcessingFeature (ILoyaltyIntegrationSpec)

# .github/CODEOWNERS (or equivalent)
/src/MegaCorp.Requirements/      @megacorp/architecture-team
/src/MegaCorp.Specifications/    @megacorp/architecture-team
/src/MegaCorp.Requirements/Features/OrderProcessing*  @megacorp/order-team
/src/MegaCorp.Requirements/Features/Payment*           @megacorp/payment-team
/src/MegaCorp.Requirements/Features/Inventory*         @megacorp/inventory-team

50 projects, ~520 hidden dependencies, 0 feature types.

Developer question: "What implements Order Processing?"
Answer: Unknown. Grep for "Order" → 247 files. Trace ServiceLocator calls → 2.5 hours.

PM question: "Is Order Processing complete?"
Answer: Unknown. Check Jira → 6 tickets over 5 years. Some ACs updated, some not.

QA question: "Are all ACs for Order Processing tested?"
Answer: Unknown. 87% code coverage. 0% requirement coverage.

New developer question: "What does this codebase do?"
Answer: Open the solution. Read 50 project names. Ask a senior developer. Hope they remember.

Auditor question: "Prove that all payment ACs are tested."
Answer: 3-day manual spreadsheet exercise. Results may be incomplete.

Incident response: "OrderPricingEngine was changed. What's the blast radius?"
Answer: Unknown. PricingEngine is in MegaCorp.Core, referenced by everything.
ServiceLocator hides the actual callers. Run all tests and hope.

52 projects (+Requirements, +Specifications), 0 hidden dependencies, 8 feature types, 37 ACs.

Developer question: "What implements Order Processing?"
Answer: Find All References on OrderProcessingFeature → 37 refs, 12 files, 8 projects. 1 second.

PM question: "Is Order Processing complete?"
Answer: dotnet build → "REQ303: OrderProcessingFeature — 9/9 ACs tested (100%)". Instant.

QA question: "Are all ACs for Order Processing tested?"
Answer: TraceabilityMatrix.g.cs → 21 tests, 9/9 ACs covered. Generated on every build.

New developer question: "What does this codebase do?"
Answer: Open MegaCorp.Requirements/Features/. See 8 feature types. Read them.
Each one has ACs with typed signatures. Ctrl+Click to implementations and tests.

Auditor question: "Prove that all payment ACs are tested."
Answer: dotnet build → TraceabilityMatrix.g.cs → PaymentProcessingFeature:
5/5 ACs specified, 5/5 implemented, 4/5 tested. Missing: NoPciDataStored.
Total time: 30 seconds.

Incident response: "OrderPricingEngine was changed. What's the blast radius?"
Answer: OrderPricingEngine implements IOrderProcessingSpec.ApplyBulkDiscount
→ [ForRequirement(typeof(OrderProcessingFeature), nameof(BulkOrderDiscountApplied))]
→ Affects AC-7. Tests: Bulk_order_receives_discount, Small_order_no_discount.
→ Run those 2 tests. If they pass, AC-7 is still satisfied.

// The analyzer uses ForAttributeWithMetadataName for incremental generation
[Generator]
public class RequirementAnalyzer : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // Only re-runs when types with [ForRequirement] change
        var requirementTypes = context.SyntaxProvider
            .ForAttributeWithMetadataName(
                "MegaCorp.Requirements.ForRequirementAttribute",
                predicate: (node, _) => node is ClassDeclarationSyntax
                    or InterfaceDeclarationSyntax
                    or MethodDeclarationSyntax,
                transform: (ctx, _) => /* extract metadata */);

        // Combine with requirement registry
        var combined = requirementTypes.Collect()
            .Combine(context.CompilationProvider);

        // Generate only when inputs change
        context.RegisterSourceOutput(combined, (ctx, source) =>
        {
            // Generate TraceabilityMatrix.g.cs
            // Emit diagnostics
        });
    }
}