- Book: LLM Observability Pocket Guide
- Also by me: AI Agents Pocket Guide
- My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools
- Me: xgabriel.com | GitHub
On March 11, 2026, Atlassian co-founder Mike Cannon-Brookes posted a public announcement cutting roughly 10% of the company, or about 1,600 people, with more than 900 of them from software R&D (The Next Web, 2026). The same blog post announced that CTO Rajeev Rajan would be leaving and his role would be split into two new CTO positions: one for the Teamwork product line, one for Enterprise and trust.
Five months earlier, according to TechCrunch's reporting, Cannon-Brookes had said in October 2025 that Atlassian would employ more engineers in five years, not fewer (TechCrunch, 2026). Then in March, Atlassian disclosed a $225M–$236M restructuring charge to redirect headcount to AI and enterprise sales (Bloomberg, 2026). The framing in the announcement: "people and AI create the best outcomes." But the headcount math says the mix has changed.
I want to skip the takes about whether the layoffs were necessary. They happened. Reading the announcement as an engineer planning the next two years of your career, the interesting part is the org-chart shape it left behind. That shape tells you what kinds of work got expensive to skip.
What the announcement actually restructures
Three things changed at once, and the order matters.
First, the CTO role got split. One CTO owns shipping AI features into the products customers already pay for. The other CTO owns enterprise trust: security, governance, deployment guarantees. That split is not cosmetic. The structure suggests that "ship the AI feature" and "make the AI feature trustworthy enough for an enterprise contract" are now two full-time jobs at the executive level. They were not, eighteen months ago.
Second, the cuts concentrated in product R&D, not in sales or support. The company is not signalling that it has fewer products to build. It is signalling that the engineers it kept are expected to ship more output per head, and that AI tooling is supposed to absorb the difference.
Third, the funding source for the AI investment is the headcount itself. Cannon-Brookes wrote that the layoffs would "self-fund further investment in AI and enterprise sales." This is the phrase to underline. The layoffs are not because revenue is bad. Five weeks earlier, on February 6, Atlassian's Q2 results came in ahead of analyst forecasts (The Register, 2026). The announcement frames the cuts as a re-allocation, and the implication I read into the math is that the company values an engineer working on AI and observability more than an engineer working on the older surface area, by a margin large enough to fund severance for 1,600 people.
The signal in the org-chart split
The most useful read of this announcement, if you are an engineer, is the second CTO appointment. There is now an executive whose job is making sure AI features ship with trust attached. Trust here means evals and logging, plus the cost tracking and regression detection that come with running an AI feature for paying customers.
This is the layer most teams are still skipping. A LangChain RAG demo runs in twenty lines of Python. A LangChain RAG feature in production at an enterprise customer runs in two thousand lines of Python plus a working eval harness, plus per-tenant cost attribution, plus prompt-injection filters, plus a fallback path when the model is degraded. The first version gets you to the demo. The second version is what survives a procurement review.
Atlassian just put that gap on its org chart. They named it at the C-level. Other companies will follow because the mechanism is the same — once you sell an AI feature into an enterprise contract, you inherit the obligation to keep it working, observable, and safe. The engineers who fluently work on that layer become structurally hard to lay off, because the company cannot meet its contractual obligations without them.
What kinds of role got cut, what kinds opened
The cuts were heaviest in product R&D (The Next Web, 2026), and my read — based on which functions the announcement names as priorities — is that engineers maintaining mature, stable feature areas were exposed. The roles the announcement signals hiring against cluster around AI integration, AI-feature observability, agentic-system reliability, and enterprise trust functions like prompt safety and access controls.
If your current role is "I maintain a stable feature in a mature product surface, plus on-call rotation," your defensible move is not to learn LangChain in a weekend. The defensible move is to become the person on your team who instruments the AI features other people build. It is unglamorous work, but the company cannot ship AI to enterprise customers without it.
A "ship + measure" pattern, by example
A junior LangChain RAG setup looks like this. Sixteen lines.
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
vs = Chroma(
collection_name="kb",
embedding_function=OpenAIEmbeddings(),
)
qa = RetrievalQA.from_chain_type(
llm=ChatOpenAI(model="gpt-4o-mini"),
retriever=vs.as_retriever(search_kwargs={"k": 5}),
)
print(qa.invoke({"query": "what's the refund policy?"}))
It works. It would also be the first thing cut by the enterprise-trust CTO under "we cannot ship this to an enterprise customer." Here is the shape of what gets layered on top to make the same code production-grade. This is the work that is now load-bearing. (The helpers cost_today, retrieve, call_llm, record_cost, and emit_eval_sample are stubs the reader is expected to wire to their own infra.)
First, the tracing scaffolding: a per-org cost ceiling, an OpenTelemetry tracer, and a context manager that wraps every query in a span tagged with the tenant.
import time
import logging
from contextlib import contextmanager
import openai
from opentelemetry import trace
tracer = trace.get_tracer("rag-feature")
log = logging.getLogger(__name__)
# Per-org cost ceiling, checked before each call.
COST_PER_1K = {"gpt-4o-mini": 0.00015, "embed": 0.00002}
ORG_DAILY_BUDGET_USD = 50.0
@contextmanager
def traced_query(org_id: str, query: str):
with tracer.start_as_current_span("rag.query") as span:
span.set_attribute("org.id", org_id)
span.set_attribute("query.length", len(query))
start = time.monotonic()
try:
yield span
finally:
span.set_attribute(
"duration_ms",
int((time.monotonic() - start) * 1000),
)
With that scaffolding in place, the answer function below uses it: budget guard before the call, retrieval-quality attributes on the span, a low-confidence refusal branch, cost recording, and an async eval sample emission.
def answer(org_id: str, query: str) -> dict:
if cost_today(org_id) > ORG_DAILY_BUDGET_USD:
log.warning("budget_exceeded", extra={"org": org_id})
return {"answer": None, "reason": "budget_exceeded"}
with traced_query(org_id, query) as span:
chunks = retrieve(query, k=5)
span.set_attribute("retrieval.count", len(chunks))
span.set_attribute(
"retrieval.min_score",
min(c.score for c in chunks) if chunks else 0,
)
if not chunks or chunks[0].score < 0.2:
return {"answer": None, "reason": "low_confidence"}
result = call_llm(query, chunks)
record_cost(org_id, result.tokens_in, result.tokens_out)
emit_eval_sample(org_id, query, chunks, result)
return {"answer": result.text, "sources": [c.id for c in chunks]}
Walk through what this adds. The query is wrapped in a span with the org id, query length, and duration — a trace that survives into your observability backend with enough attributes to filter by tenant when a customer reports a regression. The cost guard checks a per-org daily budget before each call, because the alternative is one customer's runaway agent eating your monthly OpenAI bill. The retrieval span carries chunk count and min score, so you can alert when retrieval quality drops without waiting for an answer-quality complaint. The low-confidence branch refuses to answer rather than hallucinate. The eval sample gets emitted async to a queue your eval rig pulls from to compute recall over a labelled set.
None of this is novel. All of it is what Atlassian's enterprise-trust CTO was appointed to make sure ships before the customer-facing demo does.
The career-defensive move
Two years ago, the engineer who shipped AI features fastest was the most valuable. Today, that engineer is still needed, but no longer hard to replace, because the AI tools they used to ship faster are also being handed to the engineers around them. What is defensible is the work the AI tools do not do for you: instrumenting the system, picking the right eval signal, designing the cost attribution. Wiring the alerts that catch the regression before the customer does.
If you want a concrete next thing: pick a feature in your current product that uses an LLM. Find out, by reading the code, whether anyone can answer these four questions in production. What was the prompt that produced the bad output last Tuesday at 3 PM? What did retrieval return? How much did that one query cost? Did any of the eval samples regress this week? If the answer to any of those is "we'd have to dig," that is the gap. Close it. The Atlassian announcement just told you which gap is now C-level visible.
The honest read of the news cycle
There will be ten more announcements like this in 2026. The pattern from Block in early 2026 and now Atlassian is the playbook: cut a percentage to fund AI investment, restructure the C-level around AI delivery and AI trust, ship faster on a smaller team. Some of the cuts will be performative. Some will be real reallocations. Either way, the engineers who survive are the ones working on the layer the company cannot afford to skip.
That layer right now is the one between "AI feature shipped" and "AI feature trusted in production." Become fluent in it before the next announcement lands.
If this was useful
The LLM Observability Pocket Guide covers the picking-and-wiring of tracing and eval tools that turn the second snippet above into something you can actually run a team on — what to put on a span, which traces matter, where the cost-attribution boundary goes. The AI Agents Pocket Guide is the companion for the next layer up: when the LLM call gets replaced by a multi-step agent and the eval surface area gets ten times harder.
Top comments (0)