https://github.com/pontusab/directories
If you prefer AGENTS.md files using markdown, I've extracted them into my own repo:
Poor planning, check. No/inadequate documentation, check. Sloppy and janky code, check. Poor practices and methods, check. Poor and miscommunication, check. Poor technical choices, check. What am I missing?
Maybe this is just a matter of some of the top tier 100x devs and teams clutching pearls in disgust at having to look at what goes on below Mt Olympus, but this is also not any different to how code quality cratered and is still really poor due to all the outsourcing and H-1B (sorry, all you H-1B hopefuls) insourcing of quantity over quality.
I say that without any judgement, but reality simply is that this issue has long been a quantity over quality argument even before AI, and mostly for non-dev reasons as the recent de-qualification of R&D funding revealed and had a marked impact on dev jobs because the C-suite could don't use R&D funding for financial shenanigans.
If people want to hate AI, go ahead. People hated and hate on the H-1B abuses and they hate on AI now. I would hope that we can just move beyond griping and mean-girling AI, and get to a point where proper practices and methods are developed to maybe make the outcomes and outputs better.
Because again, AI is not going anywhere less than even H-1B and I am sure the C-suite will find some new way to abuse and play financial shenanigans, but it's simply not going away and we need to learn to live with it since it will seemingly only get "better" and faster as it changes at breakneck speeds.
It's proven that (agentic) LLMs work better and more efficiently when they have the proper context for the project (AGENT(S).md), the documentation is accessible and up to date (docs/ directory with proper up to date markdown) and the tooling is smooth (git hooks that prevent secrets from being pushed, forced style checking and linting).
...surprise! All of this makes things easier for actual humans too!
That doesn't match my experience at all. Before AI, generating documentation from code was either getting some embedded comments for a function call, or just list a function's arguments.
AI reads the implementation, reads the callers and callees, and provides much smarter documentation, with context. Something sorely lacking from previous solutions. Is it sometimes not completely accurate? Probably. But still a giant step forward.
Dunno how helpful that is, but they shouldn’t have to write it from scratch.
I haven't been able to get any of your recently published projects (Scribe, volknut, a few others) running successfully on linux, whether following your documentation, using the tagged releases, or reverse engineering the true functionality and CLI arguments working from your provided source code I found to have wasted my time.
It's difficult to believe you when your own documentation is entirely wrong or 404'd.
I'd genuinely love to see your projects in action, since the concepts sound promising, but you need to back it up with shipping properly.
Understand that I'm one man working on 20 projects simultaneously, with 5+ under active development at any one moment, so release stabilization and cadence will take a little bit to lock in.
This is why AI code review continues to be mostly useless in my experience. If you instruct an LLM to make PR comments it will come up with some, every time, even when none are warranted.
I do not care if engineers on my team are using AI. In fact, I think they should be. This is the new world and we need to get used to it.
But it’s still your work, your responsibility. You still have to own it. No cop outs.
Yeah "consider firing" is a bit of an extreme kneejerk reaction, but I just feel like we HAVE to create consequences for this nonsense.
I call that a good day. I've seen people push 2000 line PRs. The worst was 5000 lines. FML.
Junior dev vibe codes some slop to solve a problem that was barely a problem. The "solution" to that not-a-problem was 2500 lines of slop. Unused variables, spaghetti logic, unit tests that were clearly write-once, read-never.
The slop at that point is the meta-problem, the real problem becomes me trying to convince (through multiple rounds of code review) that this was not maintainable code, and not a tenable development model.
All those rounds of review take TIME and mental effort. At some point, when the code review takes more effort than the code owner contributed, the value proposition is shot.
Generate the code however you want (llm, bit twiddling, whatever), but the effort and care must be there. If you can't use an llm skillfully and vouch for the output, it's gonna be a no from me dawg
I save every prompt and associated ai-generated diff in a markdown file for a steganography package I'm working on.
Check out this document: https://github.com/sutt/innocuous/blob/master/docs/dev-summa...
In particular, under v0.1.0 see `decode-branch.md` prompt and it's associated generated diff which implements memoization for backtracking while performing decoding.
It's a tight PR that fits the existing codebase and works well, you just need a motivating example you can reproduce which can help me you quickly determine if the proposed solution is working. I usually generate 2-3 solutions initially and then filter them quickly based on a test case. And as you can see from the prompt, it's far from well formatted or comprehensive, just "slap dash" listing of potentially relevant information similar to what would be discussed at an informal whiteboard session.
Fastly profits from"AI" just like Cloudflare (or should we say "Claudeflare").
This selection of developers does seem representative at all. The new strategy is to acknowledge "AI" weaknesses but still adamantly claim that it is inevitable.
This reminds me of web3, where almost all projects were just web3 infrastructure or services, to the point that the purpose of most start-ups was completely inscrutable to outsiders.
I'm having lots more hope for AI though.
You don't necessarily want to completely tune out while you're using the AI. You want to know what it's up to, but you don't need to be at your highest level of attention to do it. This is what makes it satisfying for me, because often it eats up several minutes to hunt down trivial bugs. Normally when you have some small thing like that, you have to really concentrate to find it, and it's frustrating.
When the AI is on a multi-file edit that you understand, that's when you can tune out a bit. You know that it is implementing some edit across several instances of the same interface, so you can be confident that in a few minutes everything will build and you will get a notification.
It's as if I can suddenly make all the architecture level edits without paying the cost in time that I had previously.
When you are working with AI, you are effectively working with a group of novice people, largely with basic competence, but lacking many deeper skills that are largely developed from experience. You kind of get what you put into it with proper planning, specificity in requests/tasks, proper organization based on smart structuring of skillsets and specializations, etc.
This may ruffle some feathers, but I feel like even though AI has its issues with coding in particular, this issue is really a leadership question; lead and mentor your AI correctly, adequately, and appropriately and you end up with decent, workable outcomes. GIGO
TL;DR: assuming you've squashed all regular non-determinism (itself a tall ask), you either need to ensure you always batch requests deterministically, or ensure all kernels are "batch invariant" (which is absolutely not common practice to do).
1. Replace junior developers with AI, reducing costs today.
2. Wish and hope that senior developers never retire in the future.
3. ?
I'm only half-joking: personally I'll be looking very closely at the IPO prospectus of any company founded in/after 2024 or so, to know how much vibe coding risk I can expect in its long-term prospects.
2. ?
3. Profit!
The Software Engineers Paid to Fix Vibe Coded Messes
AI can be a helpful assistant but they are nowhere near ready for letting loose when the results matter.
I’ve had good results with Claude, it just takes too long. I also don’t think I can context switch fast enough to do something else while it’s churning away.
Kind of wild watching engineers, technologists, etc clutch their pearls
AI makes mistakes - so do people - I’ve been paid many a time to go clean up the non-AI generated code humans left behind. I’ve spent countless hours troubleshooting dumb bugs generated by humans
AI brings its own set of problems but I think some people just don’t want to hear what a net benefit it is
Post after post lamenting that no machine will ever replace the human touch is so old - people have been saying that about new technology since the beginning of time
I say embrace it - great to talk about its problems objectively and how to avoid common issues, but it’s tiresome to hear all the reasons why it’s crap all the time
I would instead love articles (you do see them here sometimes) that go over how people coded complex solutions to problems using AI and the challenges they faced along the way
Knowing where the weak points are or where it may be prone to error
If you don’t embrace it, pretty soon kids coming out of college that grew up with it that contrary to popular DO understand fundamentals are going to be running circles around the people who haven’t yet figured out how to get value out of it - while you’re out there saying it’s crap and only idiots use it, these kids are going to be moving mountains - I can’t wait to see the cool stuff people build - I don’t see the future as bleak
AI just makes ambition and competition go up.
Here I put ClaudeCode in a while loop and clone itself: https://www.reddit.com/r/ClaudeCode/s/TY3SNp7eI9
After a week it was ready, you just need a good prompt.
People who say it cannot create anything beyond simple things are wrong. In my experience you can create anything provided your plan is good.
Does it end up like having colleagues who are aren't doing or understanding or learning from their own work, and are working like they offshored their job to an overnight team of juniors, and then just try to patch up the poor quality, before doing a pull request and calling their sprint done?
Or is it more like competent mechanical grunt work (e.g., "make a customer contact app with a Web form with these fields, which adds a row to the database"), that was always grunt work, and it's pretty hard to mess up, and nothing that normally the person you assigned it to would understand further anyway by doing it themself?
yes
- other team opens jira ticket requesting a new type of encabulator
- random guy who doesn't know anything of how the current encabulator system works picks up the ticket for whatever reason
- 10 minutes later opens a 2000 line vibe coded pr with the new encabulator type and plenty of unit tests
- assigns ticket to the person who designed the current encabulator system for review
- encabulator system designer finds out about this ticket for the first time this way
- "wait wtf what is this? why are we doing any of this? the current system is completely generic and it takes arbitrary parameters?"
- waste an hour talking to the guy and to the team that requested this
- explain they could just use the parameters, close pr and ticket
Had our junior dev working on a case actually ran the code in the merge request and looked at the result, it would have been obviously broken and unusable. Like not even wrong value, it would have spewed a bunch of HTML into the page.
Reviewing a co-worker of 13 years now gives me the exact same unpleasant feeling as opening an MR from a junior where I know it's going to be garbage and I'm tired of struggling to let them down easy.
> AI systems do not currently speed up many or most software developers
> AI systems in the near future will not speed up developers in our exact setting
> There are not ways of using existing AI systems more effectively to achieve positive speedup in our exact setting
I spend ages crafting the perfect prompt only to cross my fingers and hope that the output is what I want it to be when I could have just spent all that time actually crafting the document exactly as I want it to be in the first place. Often I then need to spend more time editing and tweaking the output from the AI anyway.
I’m honestly starting to feel a little crazy because I’m the only one at my workplace that sees it this way.
It is nice as a tool to help solve some hairy stuff sometimes.
It's just really hard to convert requirements to English when there are a bunch of land mines in there that you know how to avoid.
I know that it's always been this way to some degree, but this is getting out of hand.
My new job pushes cursor somewhat heavily and I gave it a try, it works pretty well for me although it's definitely not something I would rely on. I like being able to ask it to do something and let it go off and come back to it in a while to see how it did. For me, I think it makes it easier to start on changes by coming into something (that might be wrong and bad), but for me personally having something in a PR to start from is a nice mental hack.
If it did well enough on the initial attempt I'll try to stick with it to polish it up, but if it failed terribly I'll just write it by hand. Even when it fails it's nice to see what it did as a jumping off point. I do wish it were a bit less prone to "lying" (yada yada anthromorphization it's just tokens etc.,) though, sometimes I'll ask it to do something in a particular way (e.g., add foo to bar and make sure you X, Y, and Z) and it'll conclude (rightfully or not) that it can't do X, but then go on anyway and claim that it did X.
I wish it were easier to manage context switching in cursor though, as it is juggling IDE windows between git repo clones is a pain (this is true for everything though, so not unique to cursor). I wish I could just keep things running on a git branch and come back to them without having to manage a bunch of different clones and windows etc.,. I think this is more of a pain point with cursor since in theory it would allow you to parallelize more tasks but the tooling isn't really there.
edit: the starting point for this is probably worktrees, I remember reading about these a while ago and should probably check them out (heh) but it only solves the problem of having a bunch of clones sitting around, I'd still need to manage N windows.
Q1. How well do you prompt?
Q2. How reactionary are you to canceling a running prompt as soon as you see a wrong turn?
Q3. How well do you author PRs without ever saying "well AI did that part." Do you own your PRs?
Re: 1. It's a new skill set. Some engineers are not good at it. Some are amazing. And some are out of this world. You can spend a few minutes crafting a prompt that's so thorough, so well thought out but also succinct and to the point. How it touches on all the possible unknowns the AI might have as it works through the task and has direction. An out of this world prompt gets you between 90% and 95% completely done with a task that before AI would take weeks.
Re: 2. You can do very well with the first prompt but the whole other side of this is watching the AI work. Knowing when to watch very closely, and when it's okay to multi-task. Know when you immediately press ESC and tell the AI exactly what you just saw you didn't like. Catching it quickly is like early detection of cancer. You can save the rest of your day by preventing some messy dead ends before they even happen.
Re: 3. Not everyone on the team will be using AI to the level the Jedi are. And personal responsibility for your code, 90% AI generated or 0%, is still your responsibility. Once you make your PR and ask for feedback, you should no longer be able to say "oh I didn't write this part." Yes you did. No one on the team needs to know what % AI your PR was. And you don't need to know theirs.
Thats like a 2000x productivity boost. AI is amazing
So I'm genuinely asking: could you pretty please share one of these prompts? Just one. I'd honestly prefer discovering I can't prompt my way out of a paper bag rather than facing the reality that I wasted a bucketload of time and money chasing such claims.
I can have Claude write stuff that does basically the right thing and actually works but, as so many people say, it's like working with a junior dev. The only way I'm going to get code I'd want to present as my own is by sitting looking over their shoulder and telling them what to do constantly, and with a junior dev and with Claude (etc) that takes longer than just writing it myself.
AI-coded/assisted work should be flagged as such so everyone knows that it needs extra scrutiny. If we decided to let a horde of junior devs loose on a codebase we'd naturally pay more attention to PRs from new intern Jimmy than revered greybeard Bob and we shouldn't let Claude hide behind Bob's username.
Doing 2 well is the AI babysitting mentioned in the article. Of course you can stop it every minute and tell it to do something else, then watch it like a hawk to make sure it does it right, then clear context when it ignores you and makes the mistake you told it not to make. But that is often then slower than just doing the work yourself to begin with, probably leading to the findings we've all seen that LLM use is actually reducing productivity.
I think living with crappy AI code is the price we currently have to pay for getting development done quicker. Maybe in a year it'll have improved enough that we can ask it to clean up all the mess it made.
(Possibly I just have higher standards than most, other humans can be quite bad too.)
And yes, you need to develop your skills in asking for what you want, whilst still having to review the outputs similar to a junior employee. It just doesn't really learn or get better based on your feedback.
_c7zm•4mo ago