Alicia Sykes

Old code isn’t the problem. Blind rewrites are. Engineers love to blame: ❌ The legacy code ❌ The outdated stack ❌ The people who wrote it But most rewrites happen for the wrong reason: “It feels cleaner.” That’s not a reason. That’s a vibe. Before you refactor, ask: • When was this touched last, and why? • How long did the last change take? • What’s the real cost of breaking it? • Can we work around it instead? • What’s the impact if we don’t touch it at all? Smart engineers don’t rewrite to feel good. They rewrite when: ✅ The change unlocks value or speed ✅ The risk is lower than the reward ✅ They understand the full blast radius Refactoring without reasoning is tech debt in disguise. Every line you change is a bet. Make sure the upside is worth it. What’s your rule before touching old code?

1,229

177 Comments

If I had to automate workflows, here's an approach I'd consider: An IDE agent has access to your code. A CLI agent has access to your workflows. That’s because CLI agents aren’t bound to your editor. Instead they plug into your stack. They can respond to events from pipelines, logs, and tickets. They can automate tasks across GitHub, Jira, Confluence, Notion, Sentry, etc. So what kinds of use cases are CLI agents starting to take on? Automating customer feedback and support with AI agents. That's what the visual in this post distils. It’s also one of the very use cases Auggie CLI handles well. It’s a CLI agent you can run interactively or headlessly across your stack, that recently went GA. It plugs into GitHub, Linear, Jira, Notion, and more. And you can extend with MCP to fit your stack. That gives the ability to handle use cases like the above. • Agent 1: Transforms messy customer feedback into clean, structured tickets  • Agent 2: Provide support responses or ticket updates • Agent 3: Manage triage Updates are pushed back automatically into the connected tools. The alternative to achieve automated workflows like this is building complex ML classifiers or rule-based systems. But with a CLI agent like Auggie you get the same outcome with far less overhead, and with full context from your stack built in. Try it out: https://lnkd.in/gvRv4S8R Thanks to Augment Code for providing AI tools that have deep context, and partnering on this post. 💬 What are your thoughts? ↓

180

45 Comments

Code reviews aren’t just about catching bugs. They're about raising the bar for everyone. Yes, reviews help spot issues before they reach production. But if that’s all you use them for, you’re missing the bigger picture. Too many developers treat code reviews like a game of “gotcha". Pointing out tiny errors. Flexing knowledge. Nitpicking style over substance. But here’s the truth: no one gets better by being embarrassed. They grow when they feel safe enough to ask, fail, and learn. Here’s what code reviews should not be: ✘ A place to prove you're smarter ✘ A way to score points or find faults ✘ A ritual that leaves someone demotivated And here’s what they should be: ✔ A chance to teach, not preach ✔ A chance to share knowledge and context. ✔ A moment where both the author and review learn. Your job in a review isn’t just to approve or reject. It’s to communicate. To help the next dev avoid the same bug. To explain the why, not just the what. To help juniors feel confident, not scared. Be kind to the person. Be critical of the code. That balance is where real growth happens. The best teams? They treat reviews as a collaborative learning process. Not a quality gate. Not a judgement zone. Because strong code comes from strong feedback. But only when it comes from the right place. Code is temporary. How you made someone feel during the review? That sticks. Don’t just review code. Raise the bar. Share knowledge. Uplift people. Follow Abdirahman for more on software engineering. #softwareengineering #learning #codereviews

765

88 Comments

We no longer use vector embeddings for any clinical queries, and won't anytime soon. One of the main problems we ran into using embeddings on large bodies of text was that it wasn't reliable; they'd often miss short but important statements, or include sections that were semantically similar but irrelevant. More importantly, we had an extremely limited ability to tweak the performance of embeddings. This not only made debugging really difficult, but limited how much control we have over needle-in-haystack style searches over text. Instead, we switched to a reasoning powered, filtering-based approach to context construction. We have a system of rules, heuristics, and lightweight models that pull out only the most relevant notes and tokens for an LLM to make a decision on. As a result we have much better control over the quality of our outputs and, perhaps even more importantly, it gives us a way to understand and remove errors in datasets at scale. First, our model asks low-cost questions that tell us how the documents are built: - What types of documents do we have, and which ones are most relevant? - Which headers consistently anchor signals? - Are there reliable start/end “fences” around the information we care about? - Do key tokens (IDs, codes, short markers) show up in the right proportions? The model does this by pulling short windows of texts from the corpus of documents. That’s enough to confirm the boundaries and the line shape without reading the whole thing. Based on those probes into the corpus, the model writes a plain-English plan like: “Keep the lines under header A and header B; stop at the next header or end of file. Ignore everything else.” No details here—just clear rules we can review and tweak. It implements slices using tools ranging from regexes to small language model calls. Then, the model picks a small random sample to slice on using its plans and runs a quick evaluation: - Did the slice include the lines that obviously contain the target data? - Did it exclude nearby boilerplate? - How many tokens would this plan send downstream? If this looks good, we apply the filters across the entire corpus. After extraction, the same reasoning model runs cheap checks: - Do counts and ranges make sense given what the doc claims? - Are there contradictions or duplicates? - Did we accidentally include a disclaimer or a methods paragraph as a “result”? If something smells off, it flags the slice rule that likely caused it. The model fixes the rule and reruns without human intervention. This resulted in powerful control over our sensitivity/specificity tradeoffs, as well as an explainable and auditable set of outputs. It also saved us orders of magnitude in costs, making it possible for our customers to run these queries on a day to day basis at scale. Are you dealing with similar challenges, or working with these types of clinical queries? Reach out-- we'd love to chat!

78

15 Comments

🚀 Tired of waiting 15+ minutes for your Spring Boot tests to complete? Your slow test suite isn't just an inconvenience - it's killing your team's productivity and creating a culture where developers skip running tests locally. The hidden culprit? Misused Spring TestContext caching. In my latest article, I showcase how the Spring Test Profiler can help you: ⏲️ Identify which tests force expensive context recreations 📝 Get specific recommendations to maximize context reuse ⏱️ Achieve 50-80% faster test execution times 🧪 Transform test optimization from guesswork into data-driven decisions Real results: One project went from 18+ minutes to just 4 minutes (77% improvement) by optimizing context caching. The best part? It's completely open-source and works with Spring Boot 3.x + Java 17+. Fast tests enable fast development. Don't let slow tests be the bottleneck in your delivery pipeline. 📖 Read the full guide 👇🏻 https://lnkd.in/d-9NqCMu

48

Blogged: Converting an xUnit test project to TUnit https://lnkd.in/eRKYKwnX In this post I discuss the new TUnit testing framework, why I ported one of my libraries to use it instead of xUnit and related issues I had to deal with #dotnet #testing

64

Don't make the mistake of assuming that, because there's no formal code review (e.g., with a Pull Request) that code isn't being reviewed. It might be that code's actually being reviewed *continuously*, and with much more focus and rigour. For example, when I'm doing TDD, after I've passed the newest test and committed the code, I review the code I've added or changed. And I'm quite systematic about - readability, duplication (Rule of Three), complexity, coupling and cohesion, common code smells (long methods, large classes, divergent change, feature envy and so on. Then I run a linter on the changed files - they can do that, dontcha know? - to look for any low-level issues I might have missed; unused imports, fields that could be immutable, methods that could be private, etc etc. And if there are issues, I refactor. And after each refactoring, when my tests are passing, I review the code again in case my refactoring has made the code worse - e.g., harder to understand - and if it has, I might revert/undo and try something else. And you might be thinking, "Gee, that sounds like a lot of work to be doing 10, 20, 30 times an hour!" But here's the thing: we're talking about a few lines of code in each review. And many issues have already been picked up as that code was being written by my pairing partner. Indeed, quite a few issues are caught before the code's even been written by just talking about what we're gonna do next. Because when you've done a gazillion code reviews, and done them systematically, you basically turn into a human linter. So, no, I don't do formal code reviews. But my code *is* reviewed. A LOT.

55

10 Comments

🤔 A quick thought for the tech industry 🤔 There's a lot of chatter about AI replacing junior developers, with some business leaders seeing it as an easy way to cut costs. But as the AWS CEO recently pointed out, this is a fundamentally flawed strategy. Here’s why axing your junior talent in favor of AI is a short-sighted move: 👉 You're cutting off your future talent pipeline. Today's junior engineers are tomorrow's senior architects, team leads, and innovators. If you stop hiring and training them, who will you have to lead your company in 5-10 years? You can't just buy senior talent forever. 👉 You're firing the most AI-native generation. Juniors grew up with this technology. They are uniquely positioned to find creative ways to integrate AI tools into workflows. Firing them means losing the very people who can best help your company adapt and evolve. 👉 You're mistaking a tool for a professional. AI is an incredible assistant, but it can't replace the human process of learning, mentorship, and gaining institutional knowledge. A junior role isn't just about writing code; it's about growing an engineer who understands your systems, culture, and customers. 💡 Instead of focusing on replacement, let's focus on augmentation. We should be using AI to supercharge our junior engineers—automating the repetitive stuff so they can focus on learning complex problem-solving, system design, and the collaborative skills that build great teams. Investing in junior talent isn't an expense to be cut; it's an investment in the long-term health and innovation of your company. Let’s build up our people, not replace them.

48

4 Comments

Most engineers obsess over the code. I care more about the database. Here’s why: You can refactor code in hours. But fixing a bad database design in production can take months. Every schema shortcut or sloppy query gets multiplied across dozens of places. Code quality matters. But database design is where most long-term software pain comes from. If you want scalable, maintainable systems: Stop sweating every line of code. Start sweating the database architecture.

1,396

135 Comments

Tonight I will be joining a session with the Chrome DevTools team to talk about the network debugging experience in DevTools. Thanks Barry Pollard for connecting me 🙌 One of my own feedback points: 👉 It’s difficult to capture and share request + response details. When a network error happens, developers often need both the request info (URL, headers, params) and the response (body, status code) in one place. Right now, DevTools doesn’t have an easy one-click export or screenshot for this, which would be super useful for bug reports and troubleshooting. --- The team is also focusing on challenges developers face when debugging network issues end-to-end (from back-end to front-end), such as: - Working with / integrating between multiple disjointed systems - State management challenges that make it hard to reproduce bugs reliably - Difficulty understanding the payload of large requests, or dealing with 100s of network requests on a single page (noise, latency, etc.) - The complexity and limitations of end-to-end tracing across deeper back-end components or distributed systems - Difficulty reproducing real-world conditions (e.g. prod vs. dev, latency and bandwidth inconsistencies) - Not being able to inspect network activity due to security constraints 💬 If you’ve got your own pain points with the Network tab, please drop them in the comments and I’ll pass them along! Thanks for your input, everyone 💛

50

3 Comments

It’s been a while since I posted here… blame it on Gradle builds taking longer than expected. But I thought I’d get back by sharing a little dev reflection. What Being an Android Developer Really Feels Like Every Android dev I know has a story. 1. That one bug that only happened on a single Xiaomi phone running OS 11. 2. The OS update that broke notifications a week before release. 3. The library upgrade that fixed one issue but quietly doubled the APK size. 4. And of course… Gradle builds that test your patience (and your coffee supply ☕). It’s chaotic. Sometimes frustrating. But that’s what makes Android dev unique: 1. You learn to expect the unexpected. 2. You get good at debugging problems you’ve never seen before. 3. You learn to think in terms of devices, users, and environments, not just code. 4. And when it all works? You ship something that runs for millions of people, across countless devices and realities. That mix of chaos and resilience — that’s what makes Android devs different. Here’s to everyone who’s stared at Crashlytics at 2 AM and still showed up the next day to fix it. 👊 #AndroidDev #DebuggingLife #MobileDevelopment #Kotlin #ProblemSolving #DevReflections

105

2 Comments

'We only hire senior developers' Congrats! You're building a time bomb. Here's why: Senior-only teams create: • Echo chambers of outdated practices • Zero knowledge transfer • Expensive solutions to simple problems • 10 architects, no builders What you're really missing: • Fresh perspectives • Hunger to learn • Questions that challenge assumptions • Future leaders The brutal truth: • Your 'senior' requirements are fear-based • Your '10 years experience' is arbitrary • Your 'no junior devs' policy is expensive technical debt Why this matters: • Innovation needs new eyes • Growth requires teaching • Sustainability demands succession • AI is leveling the experience gap anyway How to fix it: 1. Hire for potential, not just experience 2. Create mentorship structures 3. Balance your team pyramid 4. Accept that juniors today code better than seniors did 5 years ago Remember: Today's 'risky' junior is tomorrow's 'savior'. What's your take on the senior-only trend? Drop your thoughts below 👇 *** P.S. If your entire team is senior developers, who's asking the 'stupid' questions that prevent stupid mistakes?

93

23 Comments

18 Subtle Rules of Software Engineering 0. You WILL regret complexity when on-call 1. Stop falling in love with your own code 2. Every single thing is a trade-off - no "best" 3. Every line of code you wrote is a liability 4. Document your designs and decisions 5. Everyone hates code they didn’t write 6. Don't use unnecessary dependencies 7. Coding standards prevent arguments 8. Write meaningful commit descriptions 9. Never ever stop learning new things 10. Code reviews are to spread context 11. Always build for maintainability 12. Always ask for help when stuck 13. Fix root causes, not symptoms 14. Software is never finished 15. Estimates are not promises 16. Ship early, iterate often 17. Keep. It. Simple. What would you add to the list? ♻️ Repost to help more developers see this. 🔔 Follow Miko Pawlikowski 🎙️ for more like this.

2,431

229 Comments

JetBrains just announced they're moving to a single, unified IntelliJ distribution starting with version 2025.3. No more choosing between Community and Ultimate - it's one IDE with features unlocked by subscription. Why does this matter? • Some previously paid features (Spring support, database tools) are becoming FREE • The open-source commitment remains, but with a twist • This signals bigger changes in how dev tools compete in the AI era I spent time analyzing the announcement and its implications. This isn't just about IntelliJ - it's about the future of IDEs in a world where AI assistants are changing how we write code. Full analysis here → https://lnkd.in/gBpSNWUu Curious: How many of you are using IntelliJ Community Edition today? What's your take on this change?

162

4 Comments