Brandon H.

Claude Code + AWS CLI = $96,000 saved in AWS bills...in 2 hours Important notice: Don't try this unless you know EXACTLY what you're doing Despite extensive preparation, before getting it to work, it managed to *delete a database instance which was very much in use*...it even added a flag to "skip creating snapshot upon deletion". It was that certain it's not needed. Thankfully it was a staging instance, we had a local copy, and managed to get it back up quickly....but it could've been much much worse... As Elon says, if you don't put back 10% of what you delete, you're not deleting enough...right? I saw some random post praising Claude Code being very good at DevOps. And I did a test run on a smaller account we run. Managed to get it to $50/mo. Down from $250... I was actually blown away at how capable it really is at this. Especially combined with the AWS CLI. Which has great commands, but who has time to type all that. The account we did this on is a legacy account that's been up for more than 10 years. We had quotes from several devs for 2-3 weeks of work with unclear results and tens of thousands of dollars. This managed to do a full analysis, a report, a phased plan and estimated savings in the first hour. The second hour was spent doing the optimisations and restoring the deleted instance. DON'T TRY THIS UNLESS YOU ABSOLUTELY KNOW WHAT YOU'RE DOING. But if you do - it's mega

29

5 Comments

If you’re using GitHub Copilot, there’s a huge opportunity you might be missing. GitHub just released a fantastic breakdown on building practical, reusable agents for your projects and teams — pulled from insights across 2,500+ repositories. If you’re working with AI-powered workflows, developer tooling, or automation inside your org, this is a must-read. It shows how to structure agents, capture context, scale patterns across teams, and avoid common pitfalls. Worth the 5-minute read: https://lnkd.in/eAigGCsB If you're already deep into Copilot, this will level you up. If you’re just getting started, it’ll help you build a solid foundation.

19

3 Comments

If you’ve spent any time working deep in build systems or maintaining open-source repositories, you develop a specific kind of professional paranoia. You stop seeing "dependencies" and start seeing "attack vectors." When your job is to ensure the integrity of a build, you realize how much of the world’s critical infrastructure is built on a "web of trust" that is, frankly, more fragile than we like to admit. One compromised build runner, one hijacked NPM account, or one malicious commit in a utility library can cascade into a global security event. But as paranoid as the "manual" era made me, the rise of AI-driven development is taking that anxiety to a new level. We are moving into an era where: * The Volume of Code is Exploding: AI allows for the mass generation of packages and pull requests. Sifting through the "noise" to find a signal of malice is becoming a needle-in-a-haystack problem where the haystack is growing exponentially. * Invisible Malice: We aren't just looking for suspicious logic anymore. We’re looking for "invisible" vulnerabilities—obfuscated code, Unicode traps, and logic bombs that LLMs can generate (or accidentally hallucinate) with terrifying ease. This recent article from Ars Technica is a perfect example of why this paranoia is justified. We are seeing supply chain attacks using "invisible code" hitting GitHub and other major repositories. As we lean harder into AI to speed up our velocity, we cannot afford to let our security verification lag behind. If we automate the creation of code without equally robust, AI-resistant validation of our supply chain, we’re just building faster roads to a cliff edge. To my fellow devs and build engineers: How are you evolving your CI/CD pipelines to handle the threat of AI-augmented supply chain attacks? #OpenSource #SupplyChainSecurity #CyberSecurity #BuildSystems #AI #DevSecOps https://lnkd.in/eDaqx5h9

4

While evaluating any performance testing tool, one of the questions I usually ask myself is: 𝗖𝗮𝗻 𝘁𝗵𝗶𝘀 𝘁𝗼𝗼𝗹 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗲 𝘁𝗵𝗲 𝗹𝗲𝘃𝗲𝗹 𝗼𝗳 𝗹𝗼𝗮𝗱 𝘁𝗵𝗲 𝘀𝘆𝘀𝘁𝗲𝗺 𝗜 𝗮𝗺 𝘁𝗲𝘀𝘁𝗶𝗻𝗴 𝗻𝗲𝗲𝗱𝘀? If you’re exploring k6, you may come across the below impressive claim  in their official documentation (https://lnkd.in/gbs-5SC7): 𝘿𝙚𝙥𝙚𝙣𝙙𝙞𝙣𝙜 𝙤𝙣 𝙩𝙝𝙚 𝙖𝙫𝙖𝙞𝙡𝙖𝙗𝙡𝙚 𝙧𝙚𝙨𝙤𝙪𝙧𝙘𝙚𝙨, 𝙖 𝙨𝙞𝙣𝙜𝙡𝙚 𝙞𝙣𝙨𝙩𝙖𝙣𝙘𝙚 𝙤𝙛 𝙠6 𝙘𝙖𝙣 𝙧𝙪𝙣 𝙖𝙧𝙤𝙪𝙣𝙙 30,000–40,000 𝙨𝙞𝙢𝙪𝙡𝙩𝙖𝙣𝙚𝙤𝙪𝙨 𝙫𝙞𝙧𝙩𝙪𝙖𝙡 𝙪𝙨𝙚𝙧𝙨 (𝙑𝙐𝙨). 𝙄𝙣 𝙨𝙤𝙢𝙚 𝙨𝙘𝙚𝙣𝙖𝙧𝙞𝙤𝙨, 𝙩𝙝𝙞𝙨 𝙩𝙧𝙖𝙣𝙨𝙡𝙖𝙩𝙚𝙨 𝙩𝙤 𝙪𝙥 𝙩𝙤 300,000 𝙃𝙏𝙏𝙋 𝙧𝙚𝙦𝙪𝙚𝙨𝙩𝙨 𝙥𝙚𝙧 𝙨𝙚𝙘𝙤𝙣𝙙. 𝙋𝙧𝙖𝙘𝙩𝙞𝙘𝙖𝙡𝙡𝙮 𝙨𝙥𝙚𝙖𝙠𝙞𝙣𝙜, 𝙪𝙣𝙡𝙚𝙨𝙨 𝙮𝙤𝙪𝙧 𝙪𝙨𝙚 𝙘𝙖𝙨𝙚 𝙧𝙚𝙦𝙪𝙞𝙧𝙚𝙨 𝙢𝙤𝙧𝙚 𝙩𝙝𝙖𝙣 100,000–300,000 𝙧𝙚𝙦𝙪𝙚𝙨𝙩𝙨 𝙥𝙚𝙧 𝙨𝙚𝙘𝙤𝙣𝙙 (𝙧𝙤𝙪𝙜𝙝𝙡𝙮 6–12 𝙢𝙞𝙡𝙡𝙞𝙤𝙣 𝙧𝙚𝙦𝙪𝙚𝙨𝙩𝙨 𝙥𝙚𝙧 𝙢𝙞𝙣𝙪𝙩𝙚), 𝙖 𝙨𝙞𝙣𝙜𝙡𝙚 𝙠6 𝙞𝙣𝙨𝙩𝙖𝙣𝙘𝙚 𝙞𝙨 𝙤𝙛𝙩𝙚𝙣 𝙨𝙪𝙛𝙛𝙞𝙘𝙞𝙚𝙣𝙩. That’s a great information but as engineers, we usually want more than claims. We want to see how those numbers were achieved. This is where the k6 team’s internal benchmarking repository (https://lnkd.in/gTxzjNqt) becomes interesting. This repository documents how the k6 team benchmarked their product "k6" across different hardware and virtual machine configurations. It includes the test scripts, execution details, and measured results, offering a transparent look into their benchmarking approach. It’s worth noting that the published results are based on k6 version 0.42.0, which is not the latest release. However, even with that context, the repository remains valuable. The exact numbers may evolve over time, but the benchmarking methodology and how load was generated, what constraints were considered, and how results were reported provides useful insight into how k6 can behave under high load. If you’re already using k6, or considering it for large scale performance testing, this repository is well worth exploring. It doesn’t just tell you what k6 can do but it shows how those limits were tested. #PerformanceEngineering #k6

74

1 Comment

It uses MQTT so it must be a UNS right? So what's going on here? Two days ago I posted that the bottleneck for internal testing of new Acceleer features was the current generation of automation IDE's: https://lnkd.in/gkQyQ6FM I quickly built a test PLC in dotnet/C#. The language doesn't matter, it just needs to be something open and fast. And Acceleer can generate logic in any language, not only IEC-61131-3. Add a MQTT broker for writing and reading values to simulate the program. Next bottleneck: manually manipulating values in MQTT Explorer. Great: let's try Ignition 8.3 with the new file-based storage! First problem: Ignition blocks access to changing the files externally. (Who know how to solve this? Why is it blocked?) While I try to figure it out I ask Claude to spin up a new Vue project with Pinia for state management. Then ask it to synchronize Pinia with the MQTT broker and build some components to visualize and control the S88 Control Modules and Phases. Add some draggable faceplates and Boom: Claude is in business before I even figure out how to deal with Ignitions new storage concept ... 👀 Holy cow! The possibilities 🤯 I have been talking about the future of SCADA/PLC/DCS, but this just shows concretely what might happen: - 100% file-based code and configs - CLI-based tooling - Blazing fast toolchains - Next-gen store-based HMI/SCADA, synchronized with MQTT/OPC-UA/... - .... And no need for dedicated copilots: just let Claude & Co do what they're good at. (What? You don't believe in AI-generated PLC code? Ok how about some deterministic Code-Gen then? https://lnkd.in/gFguXyTZ) There are multiple teams actively working on this, some in public and some still in stealth. (Obviously with less vibes than what I did here ... 😉 ) Thoughts? 👇 or DM

36

22 Comments

Speed vs. Architecture: You Don't Always Have to Choose A junior engineer asked me why we were "over-engineering" a feature that just needed to ship. Fair question. Here's what led to that conversation. We were mid-way through breaking a large enterprise front-end monolith into microfrontends using Module Federation. Multiple teams, multiple release cadences, one shared shell application. The business wanted a new feature live in three weeks. The fastest path was to bolt it directly onto the existing monolith no federation, no module boundary, just ship it where the code already lived. That would have hit the deadline. It also would have undone the isolation we'd spent months building, and made that piece of functionality impossible to extract later without another rewrite. The harder problem wasn't technical, it was organizational. Product had a date. My team had a direction. Neither was wrong. So I didn't frame it as "fast way vs. right way." I broke the feature into two pieces: the UI shell and interaction logic, which could ship inside the existing federation setup with minimal extra effort, and a data-aggregation layer that genuinely needed more time to do properly. We shipped the first piece on schedule. The second piece shipped two weeks later, cleanly owned by the team that would maintain it going forward. The trade-off I made explicit to stakeholders: we could hit the original date by taking on debt we already knew would cost us later, or split the delivery and hit 90% of the value on time with the remaining piece done right. I didn't sell it as "no compromise" there was a compromise, and I said so. We didn't miss the business moment, and we didn't inherit another orphaned piece of legacy code owned by no one. The lesson for me wasn't about Module Federation specifically. It was that architecture decisions at scale are rarely "fast vs. good." Usually there's a way to decompose the problem so you can be honest about what's negotiable and what isn't and let stakeholders make an informed call instead of assuming they'd choose speed if they understood what they were trading away. That's the part of the job that has nothing to do with code. How do you usually split delivery pressure from architectural integrity when a deadline forces the question? #EngineeringManagement #EngineeringLeadership #SoftwareEngineering #TechnologyLeadership

1

Contemplating which #Java baseline version to adopt for the #Hardwood Parquet parser project (https://lnkd.in/e5fjx3XW). TL,DR: I'm converging on Java 21, the current penultimate Java LTS version. Historically, I have been very conservative in that regard, supporting old Java versions for as long as possible with my libraries, so as to make them runnable as widely as possible. But I feel with the increased release cadence and generally good backwards compatibility of recent Java versions, this might not be needed any longer. Up to Java 17, there were quite a few breaking changes, with the goal of getting rid of legacy cruft in the JDK, making upgrades not always exactly easy. But since then, the dust has settled, and adopting a new JDK version feels pretty much like a non-event to me these days. So I think requiring more recent versions is becoming feasible, allowing libraries to fully take advantage of recent improvements to the Java language and API. So I'm thinking it could make sense to have a policy such as requiring the penultimate LTS as a baseline for a library. I.e., right now, Java 25 is the current LTS, so a library like Hardwood would require Java 21 or newer at this point, which should a good balance of being able to benefit from relatively recent Java improvements (Java 21 has been released in 2023), while giving folks time to upgrade (which again, has become pretty much trivial after 17, and it's only ever getting easier with LLM-based coding agents). When the next LTS comes out, the baseline could be updated to Java 25. Does that sound reasonable to folks? Too aggressive? Too conservative? Curious about your take. Would love to learn what kind of policy other library authors are adopting.

33

15 Comments