The notebook Guide
From a service change to a shared release
A change can look reasonable inside one service and still leave someone else with a difficult integration or an unexplained failure. I want the people picking up that work to have enough context to understand what changed and what still needs checking.
These two articles look at different scales of that problem. Start inside a Go service for application boundaries and tests, or across teams for checking a customer journey before release. Their examples are separate; the connection is how people make and review a change together.
Make one service easier to change
How I structure Go microservices for change starts with a booking operation that an HTTP endpoint and a broker consumer both need to call. Extracting that operation gives the application boundary a purpose: preserve shared behavior while each adapter handles its own protocol.
Read it when a change requires understanding too much unrelated code, or when business rules keep getting copied between callers. Consumer-owned interfaces, an explicit time input and composable handlers make particular dependencies easier to inspect and substitute in tests. The examples also show what those tests leave to the real adapters and service wiring.
The booking's retry policy is deliberately left open. Sharing a handler does not decide what should happen when an accepted request arrives again after its hold has expired. Someone has to agree on that behavior before a wrapper can safely retry it.
Give an agent enough context to preserve behavior
The later sections of the Go article follow the same extraction as an agent-assisted task. The useful context includes the existing behavior, the dependency rule and the checks that can detect a mistake. It also identifies the unanswered policy question, so the agent can leave that decision visible.
Read those sections when an agent's report says that tests pass but you still cannot tell whether it preserved the requirement. The report should connect its claims to checks, including anything that could not run. A reviewer still needs to examine the interpretation of the task and changes to the tests themselves.
This approach can start with repository instructions and existing build targets. The article describes additional tooling as experimental; using it is not a prerequisite for the extraction.
Check the behavior that crosses team boundaries
CI/CD Across Team Boundaries uses a different example: preserving an express-delivery choice from an order request through an event and into the customer's view. Each service can pass its own checks while that shared behavior is still wrong.
Start here when teams keep reconstructing the same cross-service test setup, or when a passing result is difficult for another team to interpret. The article combines a small scenario-based environment with shared image-delivery jobs, while teams retain their own build tools and service checks.
A passing scenario describes the combination that ran. Another service version or a relevant configuration change can leave a release proposal outside that coverage. The article follows how teams retain that evidence, coordinate a rollout and give operators authority to stop it.
Leave the next person something useful
For a real change, write down the behavior being preserved and any policy questions that still need an answer. Choose checks that exercise the affected boundaries, then make their results understandable to whoever reviews or deploys the work.
The amount of machinery should follow the problem. A second caller can give an application boundary a job; repeated cross-service changes can justify a maintained testbench. Someone will have to maintain those additions. If the shared setup costs teams more time to interpret and repair than it saves, that is a reason to simplify it.