I started learning Go (seriously) a few months ago, finally decided to use it for a production project today.
I thought it might take days, but it took hours to finish, really surprised.
Go open source really puts a lot of TLC into their projects.
Just watched a documentary on Business Insider on how Uber takes advantage of drivers, and then looked at why the left the TZ market, we really need a local solution to disrupt that market, am thinking what if we have an app, drivers pay a subscription fee, flat of like 5k a month, and basically everything you make, you take home 100%
When you join a new team, make your first impression on a contribution, not a critique.
It’s wiser to spin up on the surrounding context, demonstrate your ability and willingness to contribute, and THEN suggest the improvement.
This shouldn’t take long.
Almost always, your critique is either
1) completely off base, which you only realize after spinning up on the surrounding context, or
2) correct, and everyone on the team is already aware, but they haven’t had the bandwidth to address it (possibly because it’s not a top priority).
upon Doing The Thing, you will invariably find two things to be true:
1. Doing The Thing was pretty easy, actually
2. not having Done The Thing was bothering you more than you thought it was
Code is actually the right abstraction.
Too often I see the future of software engineering diminished down to, effectively, writing and reviewing markdown files.
Yes, it will be hard to review thousands of lines of agent code. But maybe the takeaway is that you want less code?
Rather than just giving up ("well I guess we won't read the code, or we'll read this lossy markdown summary") this should be a signal forcing you to think about better systems.
- How can we make our codebase more verifiable? For example, fast/robust/stable tests, or moving to a typed language.
- How can we deslop or improve the architecture/abstractions of the code generated by agents? For example, spending more time up front on the codebase architecture/types before yolo generating all of the code.
- How are we going to maintain and evolve this codebase over time? The slop compounds. One great solution here is... you guessed it, learning from the past decades of software engineering! For example, you might just have the wrong abstraction entirely, leading to a ton of duplicated code.
I think the markdown folks *are* right in some ways. If you are using skills every day, for many different prompts and workflows, isn't that effectively "coding with markdown"? Kinda.
There's been plenty of ink spilled on the merits and benefits of skills. To me, skills make your style of working legible for agents. They don't replace code and that's not really the point.
In reality, there's this messy and constantly re-evolving future in which both of these things are true:
1. Skills (and markdown) are important for how you give input to the agents and ensure high-quality code & systems are created
2. Looking at the actual code will not be replaced by markdown summaries or a collection of spec documents that ignore the lower level details of the code
In summary: reality has a surprising amount of detail (and nuance)!
It’s 2018 and your coworker just sent you a 400 line pull request.
You get a cup of coffee and sit down to review it.
It’s beautiful. Elegant micro-refactors. Crispy method names.
You catch a few things, but that’s ok. It’s part of the dance. They didn’t consider extensibility on part of their API. Here’s a comment buddy.
They respond in an hour saying they think we should do one piece differently than your comment. Hey let’s jump into a room and figure it out. We can’t just agree to disagree, this code is too important.
The PR merges and goes to prod. You feel a shared sense of ownership and accomplishment.
That night you go to sleep and dream of that code. You can still see the shapes of it on the backs of your eyelids, your IDE syntax highlighting sparking neurons in your reptile brain.
You go to work the next day ready to go. You understand the system. N is your foundation. Time to build n+1.
Non-technical teams are now shipping production code with no oversight from managers who are busy with 15+ direct reports and getting their hands dirty being player-coaches.
Sounds like exactly what I want in my financial institution.