Glad you gave yak-shaving a proper definition. I was always annoyed at my boss for insisting on a particular arrangement of import statements in typescript files. For him, it was a way of telling us to be more mindful of the code we typed. But mostly I’d have preferred a simple eslint config with autofix on save. This kinda yak shaving is no fun - trust me
Task tracking is now obsolete. Only the slowest most inefficient firms do this. So yes, I am learning as well how tasks are now effectively harder to create than actually implement, I tend to be a bit verbose and sometimes research the codebase for how a feature ought to be executed. All in all my tasks could eventually be done faster by llm’s
Personally, since I only do cosmetic changes to PRs like refactoring them to fit into the current codebase and sprinkling some best practices here and there - I haven’t noticed any decrease in coding velocity.
I have fond memories of this project. Contributing to it really helped me ramp up my dev skills and was effectively my introduction to monorepo’s in JavaScript. It was the kind of codebase I couldn’t get my hands on while working in my part of the world. Good luck going closed source.
All the author’s reasons for wanting the raw text that wasn’t altered by AI are all the reasons why I like to pass my messages through llms because for most people clarity in thoughts is not a given.
Often, in formal communication, I find it makes a lot of sense to make it as robotic and to the point as possible because informing my boss about the progress of a project shouldn’t leak any emotions. This is not a romantic or social relationship where emotions need to be expressed.
And I like the idea of setting goals for what I want to convert and having these llms go through the message and let me strip out the fat and ensure there is little room for misinformation and digression.
So yeah, what the author wants probably works more in an informal social setting than in a formal.
I was reading the above PR and a couple of others that were rejected primarily because the person making the PR didn't even understand the problem to begin with.
LLMs tend to make most people feel like they can
write code without understanding the problem at
hand. In a lot of cases, they even climb the
ladder of ai-suggested designs and end up with
what is probably poorly designed but works anyway.
That probably fuels their confidence and gets them
to continue - I get away with some of these things
on most reactive UI frameworks.
When doing systems programming however, it is hard
to get away with poorly designed, conceived and
executed work. Especially in open source projects
where a couple of maintainers have to retain
context of the entire project over a long period of
time to facilitate their ability to review and
make community contributions possible. These people
tend to understand the product deeply and tend to
also do gate-keeping for the quality of code that is
contributed. Without that gate-keeping, open source
might just not be sustainable.
Today with all these llm tools, people just get up
and feel like they can ai-slop their way to PRs on
open source projects. This is a maintenance burden
on open source maintainers that I fear will only
increase over time.
It is probably time for github to implement a policy of enabling maintainers to ban some users from making
a PR?
Your setup is interesting. I’ve had my mind on this space for a while now but haven’t done any deep work on a setup that optimizes the things I’m interested in.
I think at a fundamental level, I expect we can produce higher quality software under budget. And I really liked how you were clearly thinking about cost benefits especially in your setup. I’ve encountered far too many developers that just want to avoid as much cognitive work as possible. Too many junior and mid devs also are more interested in doing as they are told instead of thinking about the problem for themselves. For the most part, in my part of the world at least, junior and mid-level devs can indeed be replaced by a claude code max subscription of around $200 per month and you’d probably get more done in a week than four such devs that basically end up using an llm to do work that they might not even thoroughly explore.
So in my mind I’ve been thinking a lot about all aspects of the Software Development LifeCycle that could be improved using some llm or sorts.
## Requirements. How can we use llms to not only organize requirements but to strip them down into executable units of work that are sequenced in a way that makes sense. How do we go further to integrate an llm into our software development processes - be it a sprint or whatever. In a lot of green field projects, after designing the core components of the system, we now need to create tasks, group them, sequence them and work out how we go about assigning them and reviewing and updating various boards or issue trackers or whatever. There is a lot of gruntwork involved in this. I’ve seen people use mcps to automatically create tasks in some of these issue trackers based on some pdf of the requirements together with a design document.
## Code Review - I effectively spend 40% of my time reviewing code written by other developers and I mostly fix the issues I consider “minor” - which is about 60% of the time. I could really spend less time reviewing code with the help of an llm code reviewer that simply does a “first pass” to at least give me an idea of where to spend more of my time - like on things that are more nuanced.
## Software Design - This is tricky. Chatbots will probably lie to you if you are not a domain expert. You mostly use them to diagnose your designs and point out potential problems with your design that someone else would’ve seen if they were also domain experts in whatever you were building. We can explore a lot of alternate approaches generated by llms and improve them.
## Bugfixes - This is probably a big win for llms’ because there used to be a platform where I used to be able to get $50s and $30s to fix github bugs - that have now almost entirely been outsourced to llms. For me to have lost revenue in that space was the biggest sign of the usefulness of llms I got in practice. After a typical greenfield project has been worked on for about two months, bugs start creeping in. For apps that were properly architected, I expect these bugs to be fixable by existing patterns throughout the codebase. Be it removing a custom implementation to use a shared utility or other or simply using the design systems colors instead of a custom hardcoded one. In fact for most bugs - llms can probably get you about 50% of the way most of the time.
## Writing actual (PLUMBING) code . This is often not as much of a bottleneck as most would like to think but it helps when developers don’t have to do a lot of the grunt-work involved in creating source files, following conventions in a codebase, creating boilerplates and moving things around. This is an incredible use of llms that is hardly mentioned because it is not that “hot”.
## Testing - In most of the projects we worked on at a consulting firm, writing tests - whether ui or api was never part of the agreement because of the economics of most of our gigs. And the clients never really cared because all they wanted was working software. For a developing firm however, testing can be immense especially when using llms. It can provide guardrails to check when a model is doing something it wasn’t asked to do. And can also be used to create and enforce system boundaries especially in pseudo type systems like Typescript where JavaScript’s escape hatches may be used as a loophole.
## DEVOPS. I remember there was a time we used to manually invalidate cloudfront distributions after deploying our ui build to some e3 bucket. We’ve subsequently added a pipeline stage to invalidate the distribution. But I expect there are lots of grunt devops work that could really be delegated. Of course, this is a very scary use of llms but I daresay - we can find ways to use it safely
## OBSERVABILITY - a lot of observability platforms already have this feature where llms are able to review error logs that are ingested, diagnose the issue, create an issue on github or Jira (or wherever), create a draft PR, review, test it in some container, iterate on a solution X times, notify someone to review and so on and so forth. Some llms on this observability platform also attach a level of priority and dispatch messages to relevant developers or teams. LLms in this loop simply supercharge the whole observability/instrumentation of production applications
But yeah, that is just my two cents. I don’t have any answers yet I just ponder on this every now and then at a keyboard.
I suppose I can understand for accounting purposes to some extent. Once a purchase is done, they receive their cash immediately but perhaps actual revenue is deferred until actual usage since that will end up leading to the "actual" rendering of service by openai. Makes accounting sense.
Even though it gives me the vibes of something the fictional " Sirius Cybernetics Corporation", would do.
I suppose they are still shipping these things. With mcp integration and bluh, bluh, bluh. I marvel always at how much has changed and also how little has changed in building websites. My verdict: little has changed on the web. We just have too much commercial interest and a bunch of cs grads that need to do something with their theoretical skills.
reply