I’m working on a passion hardware project with no professional experience in embedded. I got to a fully functional prototype in 5 days instead of at least a couple of months to ramp up on the sensor datasheets, the firmware development, the CAD work needed etc.
BUT getting it to become a full fledged market ready product? That’s not gonna happen at the same pace and most definitely not gonna happen without professional embedded engineers who can optimise the PCB design, know the certification requirements, design for real world situations.
TLDR; everyone is going to do their work a little bit faster from now on, but the barriers for non subject matter experts to perform at the same level is still very high.
For anyone spending their weekend patching their homelabs, VPSs, or anything self-hosted
$> tmux new -s copilot-patching
CTRL+b c
New window for each VM / VPS
SSH into your VMs and PVEs in each window
Then ask your agent to use the copilot-patching tmux session to do the upgrades, cleanups, hardening of your setup, fixing your firewall settings.
You're welcome.
Of course you can micromanage your agent. My argument is that harnesses are pushing in the direction of trust while trust is not a given. Instead of encapsulating the how, we should find better ways to flesh it out. Plans are one way, but I think there must be better ways. Also, continuous steering and correction primitives are needed
We've entered the phase of AI writing code that I can barely understand.
The worst part is that even if I align with the model on a methodology, the agentic harnesses are fully encapsulating the intermediary steps needed to make sure the model & agent stay on track.
I often find myself needing to have elaborate "debriefings" after the fact to force the agent to reveal "how" it went about its work, and for the past several weeks those haven't ended well.
I've been experiencing:
- Misalignment on intentions that were never part of the context, because I'll always have context that is just not written anywhere.
- Assumptions made by the models in the intermediary steps that were never shared with me, but the model assumed they were OK.
- Exaggerating or diminishing information so that the agent can reach its objective and terminate its task; there is definitely some bias towards "finishing" work.
- Elaborate use of tools that I didn't sanction myself. For example, one model decided to load GiBs of data into a local sqlite instance to run some queries on it and remove duplicates.
The people building demoware, prototypes, throwaway apps, self-hosted solutions will most likely not experience these issues. The tasks are most likely simple, isolated, and straightforward.
The engineers running large, mission- or business-critical systems (distributed or otherwise), building on top of years of embedded institutional knowledge, mistakes are not acceptable.
I don't have solutions to these problems. I'm currently experimenting with:
1. Forcing the models to use simple language, not to invent jargon especially that's not provided as context.
2. Forcing the models to maintain an evidence trail especially when they are running data analysis work for me.
3. To do a step-by-step walkthrough of their method and to demonstrate with evidence the outcomes they're presenting to me.
4. To maintain artifacts of the input and output so that I can review on a need basis.
This is a dangerous phase. The cutting edge models are very good at making you "believe they're trustworthy."
I often find them using unnecessarily complicated language, which can evoke in the reader a sense of trust in the outcome. Do not fall for this trap.
Verify.
Reviewing pull requests you don't even understand isn't going to save you.
@grhmc Hmm.. not sure about that. Besides Go’s ergonomics, it has a richer runtime, module system, and more types. They may seem similar at a glance, but they’re not.
Go with mem mgmnt is probably closer to Odin than C
Building GitHub Actions in a weekend?
I always chuckle a little when AI maximalists make that claim. Conceptually it sounds simple, but Actions’ architecture is far from it. This small diagram is a high level illustration of the services, components and databases involved in orchestrating and executing a workflow run and its jobs. This doesn’t even begin to cover the vast landscape needed to manage artifacts, policies, packages and the scale of the hosted runners fleet etc.
200 million jobs per day explode into billions of events, and API calls, thousands of compute cores as well as petabytes of storage.
Tomorrow I’ll be sharing at #CodeEurope26 how we solved a critical availability risk for actions, it is but one of the many work streams everyone is super busy with. No flashy tech, no obscure black box solutions, just old fashioned engineering rigor and world class execution.
If you’re in Warsaw attending the conference, don’t skip this talk and come say Hi.
This session will be recorded and I’ll share it here once it’s available.
I’ll be back to posting more educational tech content soon, but first, we need to finish making sure the CI and Agentic execution platform of the internet is well taken care of.
The usage we’re seeing is unprecedented, the scale is unprecedented, and the resource crunch is real and not just in engineering talent.
Insane amount of work is going towards stabilising and securing the platform. Actions for example isn’t only handling the growth of CI use, it’s also the platform for all agentic workloads. The strain on our dependencies is real.
It’s a multi-dimensional whammy that no one saw coming at this speed and scale. We’re working hard on it :)
In Actions we also spent a couple of years investing in a major replatforming work to help us get to 10x scale. We hit 100x that scale in the same period. We have to cope with the growth, defend from abuse, fight the malicious actors, build new features, and keep everyone sane.
Everyone and everything is firing on all cylinders!
OPINION: Over the past year or so, GitHub has received so much hate for reliability, security, and performance issues. We have often been critics ourselves. However it's important to remember that GitHub has graciously provided free version control, CI/CD, and issue tracking for nearly two decades, half of that being after the Microsoft acquisition. We shouldnt be so quick to turn on the GitHub teams as they have given us so much. If anything, we should direct criticism at Microsoft's executive team to prioritize more engineering resources to GitHub.
And to be fair, the teams have been delivering. Since the disaster run in early 2026, reliability has been noticeably better over the past few months. At SemiAnalysis, we've worked closely with our GitHub FDE @aus10stone and the GitHub Actions engineering team @nebuk89 & Bassem Dghaidi. They've been incredibly attentive, and if these folks are any indication, the old GitHub engineering culture is alive and well.
People who can simplify complicated concepts so that laymen can understand them, are not the same people as those who can only reason about simple concepts.
At the surface level the output might look identical, but that output was not fabricated by similar machines ��
The internet hides the machines well
Rich people who were too stupid to code before are now superstars. And actually brilliant engineers are made to feel stupid and redundant. Meanwhile coding has been synthesized into beige gooey calorie dense bars made from cockroaches and engineers have to line up with a small plate begging for their share from the token barons who, fortunately, at any given moment can feel generous enough to press a button that makes the tokens fly out like projectile vomit. Engineers at these companies, who sit mere inches from the spigot, frequently bless us with thinkpieces that we too should be doing what they do, and it’s actually quite unfashionable not to do so. Of course none of this is so much engineering advice as it is financial advice.
But sure, “wHy dO pEoPle hATe Ai?”