https://vacua.dev/specifications/engineering-follow-ups/https://vacua.dev/https://vacua.dev/specifications/incident-postmortems/https://vacua.dev/skills/manage-engineering-follow-ups/https://vacua.dev/skills/https://vacua.dev/specifications/https://vacua.dev/skills/write-incident-postmortem/https://vacua.dev/skills/prepare-intent-pull-request/https://vacua.dev/skills/commit-with-intent/https://vacua.dev/skills/configure-intent-project/https://vacua.dev/skills/maintain-release-manifest/https://vacua.dev/skills/maintain-intent-changelog/https://vacua.dev/skills/maintain-intent-changeset/https://vacua.dev/tags/ai/https://vacua.dev/series/ai-as-an-engineering-instrument/https://vacua.dev/tags/engineering-judgment/https://vacua.dev/thoughts/repository-evidence-is-not-an-instruction/https://vacua.dev/tags/security/https://vacua.dev/series/https://vacua.dev/tags/https://vacua.dev/thoughts/implementation-without-understanding-is-borrowed-code/https://vacua.dev/thoughts/ai-should-shorten-the-evidence-loop/https://vacua.dev/tags/decision-making/https://vacua.dev/series/engineering-decisions-and-leadership/https://vacua.dev/tags/engineering-leadership/https://vacua.dev/thoughts/quality-needs-a-risk-and-capacity-budget/https://vacua.dev/thoughts/choose-a-stack-from-constraints-not-identity/https://vacua.dev/thoughts/a-decision-record-needs-a-way-back/https://vacua.dev/thoughts/a-short-lived-token-can-still-have-a-large-blast-radius/https://vacua.dev/tags/credentials/https://vacua.dev/series/software-supply-chain-security/https://vacua.dev/tags/software-supply-chain/https://vacua.dev/thoughts/a-lockfile-gives-repeatability-not-provenance/https://vacua.dev/tags/dependencies/https://vacua.dev/thoughts/supply-chain-security-begins-with-who-can-change-the-artifact/https://vacua.dev/tags/contracts/https://vacua.dev/tags/deployment/https://vacua.dev/series/observability-and-deployment/https://vacua.dev/tags/operations/https://vacua.dev/tags/reliability/https://vacua.dev/thoughts/rollback-cannot-restore-a-contract-you-already-removed/https://vacua.dev/tags/observability/https://vacua.dev/thoughts/observability-must-answer-the-next-operator-question/https://vacua.dev/specifications/release-manifest/https://vacua.dev/tags/developer-tooling/https://vacua.dev/thoughts/from-commit-to-changelog/https://vacua.dev/tags/git/https://vacua.dev/specifications/intent-changelog/https://vacua.dev/series/release-engineering/https://vacua.dev/tags/release-engineering/https://vacua.dev/specifications/intent-changesets/https://vacua.dev/thoughts/unreleased-is-not-a-junk-drawer/https://vacua.dev/thoughts/a-pull-request-is-a-review-narrative/https://vacua.dev/specifications/intent-pull-requests/https://vacua.dev/specifications/intent-commits/https://vacua.dev/thoughts/intent-commits/https://vacua.dev/thoughts/a-cache-hit-is-not-a-freshness-guarantee/https://vacua.dev/tags/caching/https://vacua.dev/tags/laravel/https://vacua.dev/series/laravel-performance-and-operations/https://vacua.dev/tags/performance/https://vacua.dev/specifications/project-profile/https://vacua.dev/thoughts/octane-removes-repeated-boot-and-adds-state/https://vacua.dev/tags/php-runtime/https://vacua.dev/tags/databases/https://vacua.dev/thoughts/eager-loading-is-not-a-query-shape/https://vacua.dev/thoughts/a-worker-count-is-not-a-throughput-plan/https://vacua.dev/tags/queues/https://vacua.dev/thoughts/cache-the-deployment-not-the-assumption/https://vacua.dev/thoughts/a-slow-request-is-not-a-capacity-plan/https://vacua.dev/tags/architecture/https://vacua.dev/thoughts/boundaries-follow-work-without-becoming-destiny/https://vacua.dev/series/service-boundaries-and-ownership/https://vacua.dev/tags/systems-design/https://vacua.dev/thoughts/enforce-architecture-at-the-cheapest-reliable-layer/https://vacua.dev/thoughts/name-the-independent-thing/https://vacua.dev/thoughts/a-module-is-cheaper-than-a-network-boundary/https://vacua.dev/thoughts/decompose-by-change-not-by-layer/https://vacua.dev/thoughts/a-design-is-good-for-a-change-not-in-isolation/https://vacua.dev/tags/software-design/https://vacua.dev/tags/software-quality/https://vacua.dev/tags/testing/https://vacua.dev/series/testing-for-confidence/https://vacua.dev/thoughts/a-characterization-test-is-a-boundary-not-a-recording/https://vacua.dev/tags/test-design/https://vacua.dev/thoughts/a-surviving-mutant-is-a-question/https://vacua.dev/thoughts/shared-contract-tests-make-substitutability-measurable/https://vacua.dev/thoughts/a-mock-fortress-tests-a-call-script/https://vacua.dev/thoughts/choose-the-test-boundary-from-the-defect/https://vacua.dev/thoughts/coverage-tells-you-what-ran/https://vacua.dev/series/commands-events-and-processes/https://vacua.dev/tags/domain-driven-design/https://vacua.dev/tags/messaging/https://vacua.dev/thoughts/test-process-state-not-message-choreography/https://vacua.dev/thoughts/process-managers-long-running-business-processes/https://vacua.dev/tags/event-driven-architecture/https://vacua.dev/thoughts/an-outbox-moves-the-failure-window/https://vacua.dev/thoughts/publishing-events-is-not-event-sourcing/https://vacua.dev/thoughts/a-domain-event-is-a-fact-not-a-question/https://vacua.dev/tags/cqrs/https://vacua.dev/thoughts/command-query-separation-vs-cqrs/https://vacua.dev/thoughts/a-queued-command-changes-the-contract/https://vacua.dev/thoughts/a-command-bus-must-pay-for-its-indirection/https://vacua.dev/thoughts/a-valid-command-can-still-be-refused/https://vacua.dev/thoughts/a-version-column-is-not-concurrency-control/https://vacua.dev/series/application-boundaries-and-persistence/https://vacua.dev/tags/concurrency/https://vacua.dev/tags/persistence/https://vacua.dev/thoughts/loading-state-is-not-creating-it-again/https://vacua.dev/thoughts/a-mapper-connects-two-honest-models/https://vacua.dev/thoughts/what-repositories-really-do/https://vacua.dev/thoughts/a-composition-root-makes-choices-visible/https://vacua.dev/tags/object-design/https://vacua.dev/thoughts/a-hexagon-is-not-a-directory-layout/https://vacua.dev/thoughts/an-open-host-service-is-not-a-published-language/https://vacua.dev/series/domain-discovery-and-integration/https://vacua.dev/tags/systems-integration/https://vacua.dev/thoughts/an-api-cannot-tell-you-who-has-influence/https://vacua.dev/thoughts/an-anti-corruption-layer-must-own-the-translation/https://vacua.dev/thoughts/a-context-map-must-say-what-the-arrow-means/https://vacua.dev/thoughts/integration-patterns-shared-kernel-vs-published-language/https://vacua.dev/thoughts/domain-modeling-workshops-eventstorming-in-practice/https://vacua.dev/thoughts/demystifying-ddd-aggregates-entities-models-dtos-value-objects/https://vacua.dev/series/object-design/https://vacua.dev/tags/object-oriented-design/https://vacua.dev/thoughts/a-constructor-should-leave-a-usable-object/https://vacua.dev/thoughts/null-object-pattern/https://vacua.dev/thoughts/law-of-demeter/https://vacua.dev/thoughts/tell-dont-ask/https://vacua.dev/thoughts/strategy-vs-command-pattern/https://vacua.dev/thoughts/composition-vs-inheritance/https://vacua.dev/thoughts/dependency-inversion-principle/https://vacua.dev/tags/solid/https://vacua.dev/thoughts/interface-segregation-principle/https://vacua.dev/thoughts/liskov-substitution-principle/https://vacua.dev/thoughts/open-closed-principle/https://vacua.dev/thoughts/single-responsibility-principle/https://vacua.dev/thoughts/a-design-principle-is-a-compressed-failure-history/https://vacua.dev/tags/design/https://vacua.dev/series/design-before-the-pattern-name/https://vacua.dev/tags/principles/https://vacua.dev/thoughts/design-becomes-valuable-when-the-next-change-arrives/https://vacua.dev/tags/refactoring/https://vacua.dev/tags/interfaces/https://vacua.dev/thoughts/the-type-a-caller-receives-defines-the-role/https://vacua.dev/thoughts/a-method-should-tell-you-what-changed/https://vacua.dev/tags/apis/https://vacua.dev/tags/state-machines/https://vacua.dev/thoughts/construction-should-not-hide-durable-writes/https://vacua.dev/thoughts/global-state-makes-local-reasoning-impossible/https://vacua.dev/tags/time/https://vacua.dev/thoughts/framework-convenience-has-a-boundary/https://vacua.dev/tags/frameworks/https://vacua.dev/tags/transactions/https://vacua.dev/thoughts/dependencies-should-be-visible-at-construction/https://vacua.dev/tags/dependency-injection/https://vacua.dev/thoughts/a-service-class-can-become-a-procedural-junk-drawer/https://vacua.dev/tags/application-services/https://vacua.dev/thoughts/a-primitive-can-hide-a-domain-decision/https://vacua.dev/tags/domain-modeling/https://vacua.dev/tags/validation/https://vacua.dev/tags/api-design/https://vacua.dev/thoughts/boolean-parameters-hide-different-operations/https://vacua.dev/thoughts/invalid-state-should-be-difficult-to-construct/https://vacua.dev/tags/invariants/https://vacua.dev/thoughts/a-class-name-should-describe-a-role/https://vacua.dev/tags/naming/https://vacua.dev/series/changing-existing-software/https://vacua.dev/tags/compatibility/https://vacua.dev/tags/data-migration/https://vacua.dev/tags/legacy-code/https://vacua.dev/thoughts/stored-data-is-a-caller-you-cannot-find-with-code-search/https://vacua.dev/tags/migration/https://vacua.dev/tags/services/https://vacua.dev/tags/strangler-pattern/https://vacua.dev/thoughts/the-strangler-pattern-still-needs-an-exit-plan/https://vacua.dev/tags/deprecation/https://vacua.dev/thoughts/deprecation-is-a-migration-not-a-warning/https://vacua.dev/tags/phpstan/https://vacua.dev/thoughts/static-analysis-turns-assumptions-into-questions/https://vacua.dev/tags/static-analysis/https://vacua.dev/thoughts/a-code-review-should-test-the-decision-not-the-author/https://vacua.dev/tags/code-review/https://vacua.dev/tags/idempotency/https://vacua.dev/thoughts/a-small-change-limits-the-states-a-reviewer-must-hold/https://vacua.dev/tags/database-migrations/https://vacua.dev/tags/delivery/https://vacua.dev/tags/legacy-systems/https://vacua.dev/tags/planning/https://vacua.dev/thoughts/technical-debt-is-a-change-tax-you-can-name/https://vacua.dev/tags/technical-debt/https://vacua.dev/thoughts/a-rewrite-needs-a-behavior-ledger/https://vacua.dev/tags/rewrites/https://vacua.dev/tags/integration/https://vacua.dev/thoughts/parallel-implementations-are-not-a-replacement-seam/https://vacua.dev/thoughts/a-characterization-test-is-not-a-product-decision/https://vacua.dev/tags/product-decisions/https://vacua.dev/thoughts/a-characterization-suite-is-scoped-to-a-change/https://vacua.dev/thoughts/a-directory-map-is-not-a-redesign-plan/https://vacua.dev/thoughts/a-capability-interface-is-smaller-than-a-vendor-client/https://vacua.dev/series/integration-without-illusions/https://vacua.dev/thoughts/renaming-a-field-is-a-protocol-migration/https://vacua.dev/thoughts/a-cache-must-distinguish-empty-from-unavailable/https://vacua.dev/thoughts/partial-work-needs-a-child-ledger/https://vacua.dev/tags/retries/https://vacua.dev/thoughts/retry-budgets-multiply-across-layers/https://vacua.dev/thoughts/a-rate-limit-belongs-to-all-the-workers-sharing-it/https://vacua.dev/tags/rate-limits/https://vacua.dev/thoughts/an-idempotency-key-is-not-an-identity/https://vacua.dev/thoughts/a-webhook-delivery-is-not-a-unique-event/https://vacua.dev/tags/webhooks/https://vacua.dev/thoughts/map-external-data-before-it-enters-your-model/https://vacua.dev/tags/mapping/https://vacua.dev/tags/payments/https://vacua.dev/tags/boundaries/https://vacua.dev/tags/data-modeling/https://vacua.dev/thoughts/validate-at-the-boundary-you-control/https://vacua.dev/thoughts/a-third-party-api-is-an-unreliable-collaborator/https://vacua.dev/tags/failure-handling/https://vacua.dev/tags/integrations/https://vacua.dev/thoughts/an-http-200-does-not-mean-the-operation-succeeded/https://vacua.dev/tags/http/https://vacua.dev/thoughts/data-outlives-the-code-that-created-it/https://vacua.dev/series/data-that-must-survive/https://vacua.dev/tags/data-design/https://vacua.dev/thoughts/audit-history-is-different-from-application-logging/https://vacua.dev/tags/auditing/https://vacua.dev/tags/logging/https://vacua.dev/thoughts/an-index-must-serve-a-real-query/https://vacua.dev/tags/postgresql/https://vacua.dev/tags/backfills/https://vacua.dev/tags/pagination/https://vacua.dev/thoughts/pagination-needs-a-stable-order/https://vacua.dev/tags/lifecycle/https://vacua.dev/tags/retention/https://vacua.dev/thoughts/soft-deletes-preserve-ambiguity-too/https://vacua.dev/thoughts/an-identifier-should-outlive-its-storage-engine/https://vacua.dev/tags/identifiers/https://vacua.dev/thoughts/time-zones-are-part-of-the-data-model/https://vacua.dev/tags/correctness/https://vacua.dev/tags/money/https://vacua.dev/thoughts/money-is-not-a-floating-point-number/https://vacua.dev/tags/data-quality/https://vacua.dev/thoughts/null-is-a-domain-decision/https://vacua.dev/thoughts/a-migration-is-a-production-change/https://vacua.dev/tags/migrations/https://vacua.dev/thoughts/a-transaction-defines-what-must-succeed-together/https://vacua.dev/tags/distributed-systems/https://vacua.dev/thoughts/let-the-database-reject-impossible-state/https://vacua.dev/tags/causality/https://vacua.dev/tags/debugging/https://vacua.dev/thoughts/debugging-ends-with-an-explanation-not-a-green-build/https://vacua.dev/series/debugging-real-systems/https://vacua.dev/thoughts/a-release-gate-must-fail-before-incompatible-code-goes-live/https://vacua.dev/tags/deployments/https://vacua.dev/tags/configuration/https://vacua.dev/thoughts/test-cannot-prove-production-when-it-runs-different-rules/https://vacua.dev/thoughts/a-correlation-identifier-is-a-boundary-contract/https://vacua.dev/thoughts/retries-can-multiply-the-original-failure/https://vacua.dev/thoughts/a-timeout-is-part-of-the-contract/https://vacua.dev/tags/timeouts/https://vacua.dev/tags/error-handling/https://vacua.dev/thoughts/silencing-an-error-does-not-protect-the-customer/https://vacua.dev/thoughts/runtime-configuration-is-process-state/https://vacua.dev/thoughts/a-failure-timeline-can-eliminate-the-best-looking-suspect/https://vacua.dev/thoughts/logging-is-a-workload-not-a-side-effect/https://vacua.dev/thoughts/production-bugs-can-live-in-the-data-not-the-code/https://vacua.dev/thoughts/reproduce-the-failure-before-repairing-it/https://vacua.dev/about/https://vacua.dev/projects/https://vacua.dev/thoughts/