We often think of legacy code as old code. But I believe age was never the real issue.
What makes a system difficult to maintain is often the understanding we've lost along the way.
With AI changing how we build stuff, I think this is becoming even more relevant.
A few thoughts on this in my latest article:
joao-granja.com/blog/legacy-…
2
144
Couldn’t agree more. It’s not just about being able to build things anymore. It’s about knowing what matters and making things happen.
The coding interview is dead, at least for my team at Anthropic. I've seen enough to know that it no longer provides signal. I removed it from loops this month.
I have a spicy, optimistic take - I think there's an opportunity for junior engineers: felixrieseberg.com/hunger-be…
1
2
223
I explored a similar perspective in my latest article: Hiring for Judgment.
joao-granja.com/blog/hiring-…
1
116
As execution becomes easier, thinking becomes even more important: joao-granja.com/blog/thinkin…
3
92
João Granja retweeted
30 mistakes I see enterprises make with AI transformation:
1. Buying AI licences and calling it a strategy. Decide which problems you want to solve, how people will use the tools and what improvement you expect to see. Access alone doesn’t answer those questions.
2. Expecting every employee to become an AI engineer. People need different levels of training and responsibility. Helping someone use AI in their work doesn’t automatically prepare them to build and maintain a system for others.
3. Asking AI for answers before agreeing on what a good answer looks like. Start with real examples and clear criteria. Keep verified corrections as test cases, and rerun those tests when you change the system.
4. Blaming the model before checking the whole setup. A failure can come from the model, instructions, missing information, tools or the surrounding software. Investigate where it went wrong before deciding what to replace.
5. Automating a process nobody can explain from start to finish. We spoke to a team whose work moved between calls, emails, spreadsheets and shared folders. Understanding how the work actually got done was a substantial job in itself.
6. Giving an agent more access than its job requires. Limit what it can read and change, and require approval for consequential actions. Enforce those permissions in the software. An instruction telling the agent to be careful is not an access control.
7. Making data protection depend on someone remembering to delete a name. Use appropriate access controls and automated checks to limit sensitive information before it reaches the model. Removing names alone won’t address every way confidential information can be exposed.
8. Letting an agent spend money without a limit. We still meet teams with no budget cap. Set spending limits, request limits and stopping conditions, then decide what the system should do when it reaches them.
9. Counting AI usage as proof of business progress. Token consumption can help you understand adoption and cost. It doesn’t tell you whether useful work got finished. Measure results, quality and the time spent reviewing or fixing the output.
10. Letting company data end up in accounts nobody has checked. Know which services employees use, what happens to the information they enter and which settings and agreements apply. Make the approved way of working clear.
11. Choosing a model without considering what switching would involve. Understand which parts of your system depend on that provider. A different model may need different instructions and fresh testing, even when the technical connection is easy to change.
12. Paying for discovery without agreeing on what it must deliver. We heard about an engagement where the estimate kept growing, then the consultant left for another commitment. Set clear deliverables and a point at which you decide whether to proceed.
13. Committing to a plan with no way to act on what you learn. A long project isn’t automatically a mistake. The problem is having no checkpoints where real results can change the priorities or the proposed solution.
14. Launching an agent nobody is responsible for. Assign responsibility for its operation, monitoring, updates and eventual retirement. The people responsible need the authority and resources to do those jobs.
15. Buying a custom system without a plan for when the supplier leaves. Agree on documentation, access, support and handover while the relationship is working. Know who could maintain it if that relationship ended.
16. Waiting for users to tell you something has broken. You should have telemetry installed so you don't find a problem weeks later than you should have.
17. Making an agent read everything to find one thing. Give it tools that search, filter and return relevant information. Large responses full of unrelated data consume context and make the task harder to handle reliably.
18. Letting the people who built it be the only people who test it. Involve the people who do the job and understand the business. They can help identify answers that look reasonable but would cause problems in practice.
19. Testing only the situations where everything goes smoothly. Include exceptions, ambiguous requests and cases where the system should stop or ask for help. Confusing five cases with five individual items is exactly the sort of mistake your tests should catch.
20. Keeping essential knowledge in the heads of people who might leave. One company was trying to capture how experienced colleagues made decisions before they retired. Record their reasoning and examples while they can still explain and check them.
21. Assuming every AI project must wait for the ERP migration. Some read-only work may be possible against existing data. Check freshness, permissions and the work needed to adapt it later. A replica can help, but it may lag behind the live system.
22. Assuming one company’s AI success will transfer to the whole portfolio. Use that success as a starting point. Each company still needs to check whether the approach fits its work, data and business needs.
23. Expecting AI to understand terms your own departments use differently. Explain business terms, calculations and database fields. If several measures could reasonably mean “sales,” specify which one applies to the question.
24. Producing code faster than anyone can review it. Research describes how faster generation can increase the burden on reviewers. We spoke to a team where changes were piling up because every one still needed manual acceptance testing.
25. Hiring an AI engineer and assuming the rest will sort itself out. That person still needs a clear problem, access to useful data, suitable infrastructure and colleagues who understand the work. Hiring doesn’t remove those responsibilities from the business.
26. Expecting people to forget the last failed pilot. Earlier disappointments can make people less willing to trust another system. Find out what went wrong and show what has changed before asking them to invest their time again.
27. Calling a project “90% done” before testing the difficult workflows. We’ve seen projects move quickly, then spend weeks on a couple of remaining workflows. Check what is still unproven before using the feature count to estimate the work left.
28. Expecting an agent to follow rules it cannot access. Pricing exceptions, product substitutions and informal agreements may live in someone’s spreadsheet. Make the relevant rules available, keep them current and test whether the system applies them correctly.
29. Feeding AI conflicting numbers without explaining the differences. Systems may use different definitions, update schedules or reporting periods. Establish which source and definition apply to each question before expecting a dependable answer.
30. Assuming a data feed contains the whole picture. Check which customers it covers, which fields are missing and how far back it goes. Make those limitations visible so users know what the answer is based on.
What else?
João Granja retweeted
I just published a manifesto for all the developers out there who use an AI coding tool, but feel like they're not shipping much faster
I wrote 10 principles for changing how you build software with AI, based on what I've seen work for teams across Amazon
kiro.dev/topics/frontier-eng…
AI agentic Internet traffic will obviously VASTLY exceed human usage. Not a close call at all.
Cloudflare’s forecast is accurate.
For context, Global bandwidth is somewhere between 2-8 Pbps (2,000-8,000 Tbps) depending on if your measuring fiber public backhaul (like international fiber) or all public and private connections.
100,000 V3 Starlinks equals 100 Pbps 10x-50x the total bandwidth available today. If Starlinks V4s are 5x more capable we are looking at 50x-250x more bandwidth than world has today over the next 10 years.
This may sounds like a supply shock but remember ~2B people don’t have regular access to the internet today, and we are connecting robots (digital and physical agents) to the internet at an accelerating pace. Distributed sensor data collection (on and off planet) is growing. On top of that individual internet usage does steadily increasing.
In 10 years we’re probably going to move two orders of magnitude more information per second around than we do today.
João Granja retweeted
Interesting trend:
CTO/ Head of Eng / VPE folks at startups and mid-sized companies are... leaving / burning out. Hiring for these roles is HARD, but even after filling the role, they will often leave a few months later and take a career break
And they have v good reasons
João Granja retweeted
Something I have been thinking about: in the past, the best engineers I knew spent a lot of time automating their work in various ways. Better vim/emacs automations, writing lint rules to catch repeat code issues, building up a suite of e2e tests so they don't need to smoke test the app manually. These kinds of things were the highest leverage activities an engineer could do, because it multiplied their own output, which in turn meant they could build more things.
I think many of these automations have become even more important now. This is true for a number of reasons.
First, infra and DevX automation speeds you up. And if you are running an army of agents, each of those agents will be sped up also. More automation == more output per unit of time.
Second, moving things to code improves efficiency. Your agent could fix an issue every time it sees that issue happen, but that uses tokens and might miss cases. If Claude instead writes a lint rule, CI step, or routine, that class of issue can be fully automated forever. This is really what people are talking about when they talk about loops -- it's about automating entire types of busywork rather than solving them one off. This isn't a new idea at all. Engineers have been doing this for a long time!
Third and most importantly, automation makes it possible for others to contribute to the codebase more easily. Increasingly what I am seeing is engineers are contributing to codebases on day one because Claude can navigate the codebase for them, and that non-engineers are able to contribute to a codebase as effectively as engineers can. What gets in the way of both of these is domain knowledge that lives in peoples' heads rather than in automation -- the stuff you used to have to learn when ramping up. What has changed thanks to agents is the domain knowledge that can be encoded as infrastructure is no longer limited to what is expressible in lint rules and types and tests; it can now capture nearly all domain knowledge, encoded as code comments and skills and CLAUDE.md rules and memories. If I put up a PR for an iOS codebase I don't know and a code reviewer rejects it because it doesn't use the right framework, or if a designer builds a new feature and it gets rejected because it doesn't follow the right architectural patterns, these are failures of automation.
Every team should be writing the CLAUDE.md's, REVIEW.md's, skills, and docs that enable agents to productively work in their codebase with zero additional context from the prompter. This sounds crazy, and at the same time is a natural extension of the stuff engineers have always done: automate, and encode domain knowledge as infrastructure. As the model gets smarter and as the harness matures, this task becomes easier. In the meantime, it is on every team to look for ways to convert their domain knowledge to infra so that Claude can write code better, so that code review catches issues automatically, and so the next person working on your codebase can contribute more easily.
João Granja retweeted
Great distributed systems article from Discord on how they migrated from Cassandra to ScyllaDB by writing their own data access layer to coalesce concurrent queries, did a full migration of trillions of messages and saw huge p99 latency improvements. discord.com/blog/how-discord…
João Granja retweeted
"Scaling Kubernetes to multiple clusters and regions" by Daniele Polencic
buff.ly/3ZN3jhc
João Granja retweeted
"How Many SREs Does Your Company Need? Here’s How to Decide" by JJ Tang
buff.ly/3hgp8Em
João Granja retweeted
This graphic is so powerful and so true!
Prioritise your mental health everyone. Your brain is your primary work tool, don't burn it out.
João Granja retweeted
"Prometheus — Overview"
"To gain a deeper understanding of it, this series will cover how Prometheus works. In this post, we’ll take a look at the overview of Prometheus."
buff.ly/3BwBoXk
João Granja retweeted
"Building a resilient system: Our journey to observability at Intercom"
#sre
buff.ly/3cvILWc
João Granja retweeted
Kubernetes Autoscaling Evolution in 3 stages at Airbnb
medium.com/airbnb-engineerin…






















