In a 2026 DEV Community post, the handle yureki_lab says they used Claude Code to add OpenTelemetry tracing to 47 backend services in nine days. The account describes a repeatable engineering workflow—not an independently audited benchmark: establish one working example, encode conventions in a validator, verify traces at runtime, then have a person review decisions the checks cannot settle.
Why the author started the migration
The service fleet was mostly Node.js 22.x applications using Express or Fastify, with a handful of Python 3.13 FastAPI services. Structured JSON logs were already available, but distributed traces were not. The author says incident responders could spend a median of more than 40 minutes determining “which service is actually slow.” That figure is the author’s report; the post does not provide the underlying incident data or calculation.
![Claude AI for Beginners Bible: [5 in 1] The Ultimate Guide to Automate Your Work, Save Hours Every Week, and Use AI for Real-World Results](https://m.media-amazon.com/images/I/415+fSJacsL._SL160_.jpg)
As an Amazon Associate I earn from qualifying purchases.
The goal was not simply to add tracing libraries everywhere. Spans needed to be exported, connected into traces across service boundaries, and named and attributed in ways that were useful without creating high-cardinality data or exposing sensitive information.
How the nine-day workflow worked
1. Build a reference service before asking an agent to repeat the work
The author found that a prose conventions document led to inconsistent implementations. Instead, they manually instrumented one service and treated its code as the reference pattern for the rest. The Node.js bootstrap described in the post configures a NodeSDK, an OTLP HTTP trace exporter, Node auto-instrumentations, service name and version, environment attributes, and shutdown handling. Filesystem instrumentation is disabled in the example.
#1 Best Overall
This gives the coding agent a concrete implementation to follow, while leaving service-specific decisions visible for review. The example is a pattern, not proof that every service has identical instrumentation needs.
2. Make repeatable conventions executable
The author wrote a Python validator to check for a tracing bootstrap, interpolated span names, selected high-cardinality or potentially sensitive attributes, and span namespaces that did not match the service. This shifted review away from repeatedly checking mechanical conventions and toward judgment calls.
Rank #2
A validator can enforce only the rules it encodes. The account does not establish that this particular script catches every tracing, privacy, or security problem, or that it can be reused unchanged in another repository.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →3. Test exported spans and trace relationships
Static checks cannot show that a request actually produces exported spans or that context propagates between them. The author’s smoke test sends a request, flushes spans from a local collector, and checks for an HTTP span and a database span connected by a parent-child relationship. It also checks that a concrete invoice ID does not appear in the route span name.
That runtime check caught context-propagation failures that could otherwise leave separate spans instead of a connected trace. The distinction matters: code can satisfy a structural rule and still fail to produce a useful distributed trace.
4. Batch similar services and review what remains
The author grouped services by framework, repeated the agent-validator-test loop, and had a human review service-specific decisions before pull requests were merged. The post’s practical lesson is to order the backlog by similarity rather than convenience: adjacent tasks are cheaper to repeat consistently than tasks that require switching between different frameworks and patterns.
What the reported timeline does—and does not—show
According to yureki_lab, the first six services took four days and the remaining 41 took five. The author also reports spending about 90 minutes a day on the work. These are figures from one retrospective account, not independently verified measurements or a controlled comparison of agent-assisted and manual work.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallThe author estimated that manual instrumentation would take roughly half a day per service, or about six weeks for 47 services. That is an estimate, not a measured control group. The post also says the validator caught 31 cardinality violations that might otherwise have been merged, but links no code or audit record that would let readers independently check the count. None of these numbers establishes a general time saving or a typical result for other teams.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Where human judgment still matters
Automation helps repeat known conventions; it cannot safely infer every operational decision from code. The author calls out review of decisions that depend on undocumented context, such as whether old logs should be deleted. The same boundary applies to instrumentation: framework-level automatic instrumentation can cover common operations, while domain-specific work—such as queue processing, scheduled jobs, or business operations—may need deliberate design rather than mechanical replication.
- Use the reference implementation to make expected structure concrete.
- Use executable checks for conventions that can be stated precisely.
- Use runtime tests to verify export and parent-child context, not just code shape.
- Review span names and attributes for cardinality and sensitive-data risks.
- Keep repository-specific and operationally consequential choices with a human reviewer.
What the author planned next
The post says the author’s next work was to consider sampling policy, using 100% head-based sampling in staging while exploring tail-based sampling, then pursue trace-driven performance work and generated service dependency graphs. These were plans described in the post, not confirmation that the work was later completed.
What teams can take from the case study
The useful idea is the workflow, not the headline duration: start with a working reference, convert recurring rules into checks, prove behavior with a runtime smoke test, and reserve human attention for decisions that need context. The author’s experience suggests that grouping similar services can make repeated changes easier to manage, but it does not predict how quickly another team—or another codebase—will finish.
Read yureki_lab’s original DEV Community account.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
