It has also enabled a few people to write code or plan out implementation details who haven't done so in a long (sometimes decade or more) time, and so I'm getting some bizarre suggestions.

Otherwise, it really does depend on what kind of code. I hand write prod code, and the only thing that AI can do is review it and point out bugs to me. But for other things, like a throwaway script to generate a bunch of data for load testing? Sure, why not.

Or I'll walk up to your desk and ask you to explain it.

It’s the asymmetric expectations—that one person can spew slop but the other must go full-effort—that for me personally feels disrespectful.

That way, thinking is communication! That's kind of why I loved math so much - it felt like I could solve a problem and succinctly communicate with the reader at the same time.

However, since people are not going to readily reveal that they used an LLM to produce said output, it seems like the most logical way to do this is just always use an LLM to consume inputs, because there's no easy 100% way to tell whether it was created by an LLM or a human or not anymore.

This has always been the case. Have some junior shit out a few thousand lines of code, leave, and leave it for the senior cleanup crew to figure out what the fuck just happened...

If I'm feeling brave, I let it write functions with very clear and well defined input/output, like a well established algorithm. I know it can one-shot those, or they can be easily tested.

But when doing something that I know will be further developed, maintained, I mainly end up writing it by hand. I used to have the LLM write that kind of code as well, but I found it to be slower in the long run.

I've found that SoTA LLMs sometimes implement / design differently (in the sense that "why didn't I think of that"), and that's always refreshing to see. I may run the same prompt through Gemini, Sonnet, and Codex just to see if they'd come up with some technique I didn't even know to consider.

> don't forsee a need to review it myself either

On the flip side, SoTA LLMs are crazy good at code review and bug fixes. I always use "find and fix business logic errors, edge cases, and api / language misuse" prompt after every substantial commit.

Last year I was working on implementing a pretty big feature in our codebase, it required a lot of focus to get the business logic right and at the same time you had be very creative to make this feasible to run without hogging to much resources.

When I was nearly done and worked on catching bugs, team members grew tired of waiting and starting taking my code from x weeks ago (I have no idea why), feeding it to Claude or whatever and then came back with a solution. So instead of me finishing my code I had to go through their version of my code.

Each one of the proposals had one or more business requirements wrong and several huge bugs. Not one was any closer to a solution than mine was.

I had appreciated any contribution to my code, but thinking that it would be so easy to just take my code and finishing it by asking Claude was rather insulting.

We're in a phase where founders are obsessed with productivity so everything seens to work just fine and as intended with few slops.

They're racing to be as productive as possible so we can get who knows where.

There are times when I honestly don't even know why we're automating certain tasks anymore.

In the past, we had the option of saying we didn't know something, especially when it was an area we didn't want to know about. Today, we no longer have that option, because knowledge is just a prompt away. So you end up doing front-end work for a backend application you just built, even though your role was supposed to be completely different.

Something resembling knowledge anyway. A sort of shambling mound wearing knowledge like a skinsuit

I'm running Codex on a Raspberry Pi, and Claude Code CLI, Gemini CLI, and Claude in Chrome all on a Mac, all touching the same project across both machines. The drift is constant. One agent commits, the others don't know about it, and now you've got diverged realities. I'm not a coder so I can't just eyeball a diff and know which version is right.

Ended up building a mechanical state file that sits outside all the context windows. Every commit, every test run, every failed patch writes to it. When a new session starts, the agent reads that file first instead of trusting its own memory. Boring ops stuff really, but it's the only thing that actually stopped the "which version is real" problem.

At work, the devs up the chain now do everything with AI – not just coding – then task me with cleaning it up. It is painful and time consuming, the code base is a mess. In one case I had to merge a feature from one team into the main code base, but the feature was AI coded so it did not obey the API design of the main project. It also included a ton of stuff you don’t need in the first pass - a ton of error checking and hand-rolled parsing, etc, that I had to spend over a week unrolling so that I could trim it down and redesign it to work in the main codebase. It was a slog, and it also made me look bad because it took me forever compared to the team who originally churned it out almost instantly. AI tools are not good at this kind of design deconflicting task, so while it’s easy to get the initial concept out the gate almost instantly, you can’t just magically fit it into the bigger codebase without facing the technical debt you’ve generated.

In my personal projects, I get to experience a bit of the fun I think others are having. You can very quickly build out new features, explore new ideas, etc. You have to be thoughtful about the design because the codebase can get messy and hard to build on. Often I design the APIs and then have Claude critique them and implement them.

I think the future is bleak for people in my spot professionally – not junior, but also not leading the team. I think the middle will be hollowed out and replaced with principals who set direction, coordinate, and execute. A privileged few will be hired and developed to become leaders eventually (or strike gold with their own projects), but everyone in between is in trouble.

People who disagree at all levels of seniority have been made to leave the organization.

Practically speaking, there's no sexy pitch you can make about doing quality grunt work. I've made that mistake virtually every time I've joined a company: I make performance improvements, I stabilize CI, I improve code readability, remove compiler warnings, you name it: but if you're not shipping features, if you're not driving the income needle, you have a much more difficult time framing your value to a non-engineering audience, who ultimately sign the paychecks.

Obviously this varies wildly by organization, but it's been true everywhere I've worked to varying degrees. Some companies (and bosses) are more self-aware than others, which can help for framing the conversation (and retaining one's sanity), but at the end of the day if I'm making a stand about how bad AI quality is, but my AI-using coworker has shipped six medium sized features, I'm not winning that argument.

It doesn't help that I think non-engineers view code quality as a technical boogeyman and an internal issue to their engineering divisions. Our technical leadership's attitude towards our incidents has been "just write better code," which... Well. I don't need to explain the ridiculousness of that statement in this forum, but it undermines most people's criticism of AI. Sure, it writes crap code and misses business requirements; but in the eyes of my product team? That's just dealing with engineers in general. It's not like they can tell the difference.

It's best to sniff out values mismatches ASAP and then decide whether you can tolerate some discomfort to achieve your personal goals.

You’re much better off mixing both (quality work and product features).

Yes? In the same way any victim of shoddy practices is "part of the problem"?

I know a lot of people who tried playing this game frequently during COVID, then found themselves stuck in a bad place when the 0% money ran out and companies weren’t eager in hiring someone whose resume had a dozen jobs in the past 6 years.

I hope you get the privilege soon

You can should speak up when tasks are poorly defined, underestimated, or miscommunicated.

Try to flat out “refuse” assigned work and you’ll be swept away in the next round of layoffs, replaced by someone who knows how to communicate and behave diplomatically.

They clearly were not advocating for flat out refusing.

It's just plain unprofessional to just YOLO shit with AI and force actual humans to read to code even if the "author" hasn't read it.

Also API design etc. should be automatically checked by tooling and CI builds, and thus PR merges, should be denied until the checks pass.

If they're handing you broken code call them out on it. Say this doesn't do what it says it does, did you want me to create a story for redoing all this work?

The hell you are playing hero for? Delegate the choice to manager: ruin the codebase or allocate two weeks for clean-up - their choice. If the magical AI team claim they can do integration faster - let them.

IME too many don't care about on call unless they are personally affected.

This has to be the most thankless job for the near future. It's hard and you get about as much credit as the worker who cleans up the job site after the contractors are done, even though you're actually fixing structural defects.

And god forbid you introduce a regression bug cleaning up some horrible redundant spaghetti code.

I know my mind fairly well, and I know my style of laziness will result in atrophying skills. Better not to risk it.

One of my co-workers already admitted as much to me around six months ago, and that he was trying not to use AI for any code generation anymore, but it was really difficult to stop because it was so easy to reach for. Sounded kind of like a drug addiction to me. And I had the impression he only felt comfortable admitting it to me because I don't make it a secret that I don't use it.

Another co-worker did stop using it to generate code because (if I'm remembering right) he can tell what it generates is messy for long-term maintenance, even if it does work and even though he's new to React. He still uses it often for asking questions.

A third (this one a junior) seemed to get dumber over the past year, opening merge request that didn't solve the problem. In a couple of these cases my manager mentioned either seeing him use AI while they were pairing (and it looked good enough so the problems just slipped by) or saw hints in the merge request with how AI names or structures the code.

I don't use it at all to program despite that being my day job for exactly the reason you mentioned. I know I'll totally forget how to program. During a tight crunch period, I might use it as a quick API reference, but certainly not to generate any code. (Absolutely not saying it's not useful for this purpose—I just know myself well enough to know how this is going to go haha)

I started using it for things I hate, ended up using it everywhere. I move 5x faster. I follow along most of the time. Twice a week I realize I’ve lost the thread. Once a month it sets me back a week or more.

it just allucinates packages, adds random functions that already exist, creates new random APIs.

How is that not unmantainable?

If it was July 2025, I would have agreed with you. But not anymore.

Most of my gripes are with the harness, CC is way better.

In terms of productivity I'm def 2-4X more productive at work, >10x more productive on my side business. I used to work overtime to deliver my features. Now I work 9-5 and am job hunting on the side while delivering relatively more features.

I think a lot of people are missing that AI is not just good for writing code. It's good for data analysis and all sorts of other tasks like debugging and deploying. I regularly use it to manage deployment loops (ex. make a code change and then deploy the changes to gamma and verify they work by making a sample request and verifying output from cloudwatch logs etc). I have built features in 2 weeks that would take me a month just because I'd have to learn some nitty technical details that I'd never use again in my life.

For data analysis I have an internal glue catalog, I can just tell it to query data and write a script that analyzes X for me.

AI and agents particularly have been a huge boon for me. I'm really scared about automation but also it doesn't make sense to me that SWE would be automated first before other careers since SWE itself is necessary to automate others. I think there are some fundamental limitations on LLMs (without understanding the details too much), but whatever level of intelligence we've currently unlocked is fundamentally going to change the world and is already changing how SWE looks.

Sanctioned comment?

Pretty sure the answer is here :)

I own (with two other folk) my own little company and hire other people. I actively encourage my troops to have a bash but I suspect that a firm like AMZ would have differing views about what used to be called moonlighting. Mind you we only turnover a bit over £1M and that is loose change down the back of a sofa for AMZ ...

In the bucket of "really great things I love about AI", that would definitely be at the top. So often in my software engineering career I'd have to spend tons of time learning and understanding some new technology, some new language, some esoteric library, some cobbled-together build harness, etc., and I always found it pretty discouraging when I knew that I'd never have reason to use that tech outside the particular codebase I was working on at that time. And far from being rare, I found that working in a fairly large company that that was a pretty frequent occurrence. E.g. I'd look at a design doc or feature request and think to myself "oh, that's pretty easy and straightforward", only to go into the codebase and see the original developer/team decided on some extremely niche transaction handling library or whatever (or worse, homegrown with no tests...), and trying to figure out that esoteric tech turned into 85% of the actual work. AI doesn't reduce that to 0, but I've found it has been a huge boon to understanding new tech and especially for getting my dev environment and build set up well, much faster than I could do manually.

Of course, AI makes it a lot easier to generate exponentially more poorly architected slop, so not sure if in a year or two from now I'll just be ever more dependent on AI explaining to me the mountains of AI slop created in the first place.

Professionally, I have had almost no luck with it, outside of summarizing design docs or literally just finding something in the code that a simple search might not find: such is this team's code that does X?

I am yet to successfully prompt it and get a working commit.

Further, I will add that I also don't know any ICs personally who have successfully used it. Though, there's endless posts of people talking about how they're now 10x more productive, and everyone needs to do x y an z now. I just don't know any of these people.

Non-professionally, it's amazing how well it does on a small greenfield task, and I have seen that 10x improvement in velocity. But, at work, close to 0 so far.

Of the posts I've seen at work, they typically tend to be teams doing something new / greenfield-ish or a refactor. So I'm not surprised by their results.

I’ve probably prompted 10,000 lines of working code in the last two months. I started with terraform which I know backwards and forwards. Works perfectly 95% of the time and I know where it will go wrong so I watch for that. (Working both green field, in other existing repos and with other collaborators)

Moved on to a big data processing project, works great, needed a senior engineer to diagnose one small index problem which he identified in 30s. (But I’d bonked on for a week because in some cases I just don’t know what I don’t know)

Meanwhile a colleague wanted a sample of the data. Vibe coded that. (Extract from zip without decompressing) He wanted randomized. One shot. Done. Then he wanted randomized across 5 categories. Then he wanted 10x the sample size. Data request completed before the conversion was over. I would have worked on that for three hours before and bonked if I hit the limit of my technical knowledge.

Built a monitoring stack. Configured servers, used it to troubleshoot dozens of problems.

For stuff I can’t do, now I can do. For stuff I could do with difficulty now I can do with ease. For stuff I could do easily now I can do fast and easy.

Your vastly different experience is baffling and alien to me. (So thank you for opening my eyes)

Once the plan is set, using the agentic coder to create smaller CLs has been the best avenue for me. You don't want to generate code faster than you and your reviewers can comprehend it. It'll feel slow, but check ins actually move faster.

I will say it's not all magic and success. I have had the AI lead me down some dark corners, assuring me one design would work when actually it is a bit outdated or not quite the right fit for the system we are building for because of reasons. So, I wouldn't really say that it's a 10x multiplier or anything, but I'm definitely getting things done faster than I could on my own. Expertise on the part of the user is still crucial.

One classic issue I used to run into, is doing a small refactor and then having to manually fix a bunch of tests. It is so much simpler to ask the LLM to move X from A to B and fix any test failures. Then I circle back in a few minutes to review what was done and fix any issues.

The other thing is, it has visibility for the wider code base, including some of our infrastructure that we're dependent on. There have been a couple times in the past quarter where our build is busted by an external team, and I am able to ask the LLM given the timeframe and a description of the issue, the exact external failure that caused it. I don't really know how long it would have taken to resolve the issue otherwise, since the issues were missed by their testing. That said, I gotta wonder if those breakages were introduced by LLM use.

My job hasn't been this fun in a long, long time and I am a little uneasy about what these tools are going to mean for my personal job security, but I don't know how we can put the genie back into the bottle at this point.

I see it generating between 50% to 90% accuracy in both small and large tasks, as in the PRs it generates range between being 50% usable code that a human can tweak, to 90% solution (with the occasional 100% wow, it actually did it, no comments, let's merge)

I also found it to be a skillset, some engineers seem to find it easier to articulate what they want and some have it easier to think while writing code.

It's pretty clear that people think greenfield projects can constantly be slopified and that AI will always be able to dig them another logical connection, so it doesn't matter which abstraction the AI chose this time; it can always be better.

This is akin to people who think we can just keep using oil to fuel technological growth because it'll some how improve the ability of technology to solve climate problems.

It's akin to the techno capitalist cult of "effective altruism" that assumes there's no way you could f'up the world that you can't fix with "good deeds"

There's a lot of hidden context in evaluating the output of LLMs, and if you're just looking at todays success, you'll come away with a much different view that if you're looking at next year's.

Optimism is only then, in this case, that you believe the AI will keep getting more powerful that it'll always clean up todays mess.

I call this techno magic, indistinguishable from religious 'optimism'

It does work sometimes. The smaller the task, the better.

The FANG code basis are very large and date back years might not necessarily be using open source frameworks rather in house libraries and frameworks none of which are certainly available to Anthropic or OpenAI hence these models have zero visibility into them.

Therefore combined with the fact that these are not reasoning or thinking machines rather probabilistic (image/text) generators, they can't generate what they haven't seen.

LLMs learn dynamically through their context window and this learning is at a rate much faster than humans and often with capabilities greater than humans and often much worse.

For a code base as complex and as closed source as google the problems an LLM faces is largely the same as a human. How much can he fit into the context window?

Meta, despite competing with these, is open to let their devs use better off the shelf tools.

1. Degraded quality over longer context window usage. I have to think about managing context and agents instead of focusing solely on the task.

2. It’s slow (when it’s “thinking”). Especially when it’s tasked with something simple (e.g., I could ask Claude Opus to commit code and submit for review but it’s just faster if I run the commands myself and I don’t want to have to think about conditionally switching to Haiku / faster models mid task execution).

3. It often requires a lot of upfront planning and feedback loop set up to the extent that sometimes I wonder if it would’ve been faster if I did it myself.

A smarter model would be great but there are bigger productivity gains to be had with a good set up, a faster model, and abstracting away the need to think about agents or context usage. I’m still figuring out a good set up. Something with the speed of Haiku with the reasoning of Opus without the overhead of having to think about the management of agents or context would be sweet.

I've been working on this and landed on a pattern I call a "mechanical ledger", basically a structured state file that sits outside any context window and gets updated as a side effect of work, not as a step anyone remembers to do. Every commit writes to it, every failed patch writes to it, every test run writes to it. When a session starts (or an agent compacts), it reads the ledger and rebuilds context from ground truth instead of from memory.

Its not a novel idea really, its basically what ops teams do with runbooks and state files, but applied to the AI agent handoff problem. The interesting bit is making the updates mechanical so no agent can forget to do it.

I was thinking about this recently. This kind of setup is a Holy Grail everyone is searching for. Make the damn tool produce the right output more of the time. And yet, despite testing the methods provided by the people who claim they get excellent results, I still come to the point where the it gets off rails. Nevertheless, since practically everybody works on resolving this particular issue, and huge amounts of money have been poured into getting it right, I hope in the next year or so we will finally have something we can reliably use.

May I ask what you're working on?

When I write my prompts, I literally write an essay. I lay constraints, design choices, examples, etc. If I already have a ticket that lays out the introduction, design considerations, acceptance criteria and other important information, then I'll include that as well. I then take the prompt I've written and I request for the model to improve the prompt. I'll also try to include the most important bits at the end since right now models seem to focus more on things referenced at the end of a prompt rather than at the beginning.

Once I do get output, I then review each piece of generated code as if I'm doing an in-depth code review.

I have 10 years of experience. I am a reasonable engineer. I can tell you that about half of the hype on twitter is real. It is a real blessing for small teams.

We have 100k DAU for a consumer crud app. We built and maintain everything in-house with 3 engineers. This would have taken atleast 10 engineers 3-4 years back.

We don't have a bug list. We are not "vibe coding" , 2 of us understand almost all of the codebase. We have processes to make sure the core integrity of codebase doesn't go for a toss.

None has touched the editor in months.

Even the product folks can raise a PR for small config changes from slack.

Velocity is through the roof and code quality is as good if not better than when we write by hand.

We refactor almost A LOT more than before because we can afford to.

I love it.

AI is already better at understanding code than 99.99% of human, the more I use it the more I believe this is true. It can draw connections between dots far quicker and accurate than a human could ever be.

At very least, AI is going to be a must even as a co-supervisor to your project

What in doubt right now, is whether AI can manage a codebase fully autonomously without bring it down, which I doubt it can at the moment. Be it 4.6 or 5.4, they always, almost always, add code instead of removing them, the sheer complexity will explode at certain point.

But that is my assessment for models TODAY, who knows where they will end up being in 6 months. AI is entering the recursive self improvement phase, that roadmap is laying in front our eyes, what it can and would unlock is truly, truly unpredictable.

I am both intrigued and scared.

This year I grudgingly bit the bullet and began using AI tools, and to my dismay they've been a pretty big boon for me, in this case. Not just for code generation - they're really good at probing the monolith and answering questions I have about how it works. Before I'd spend days pouring over code before starting work to figure out the right way to build something or where to break in, pinging people over in India or eastern Europe with questions and hoping they reply to me overnight. AI's totally replaced that, and it works shockingly well.

When I do fall back on it for code generation, it's mostly just to mitigate the tedium of writing boilerplate. The code it produces tends to be pretty poor - both in terms of style and robustness - and I'll usually need to take at least a couple of passes over it to get it up to snuff. I do find this faster than writing everything out by hand in the end, but not by a lot.

For my personal projects I don't find it adds much, but I do enjoy rubber ducking with ChatGPT.

In fact it looks like an arising theme is that whenever we use these tools it's valuable to maintain a human understanding of what's actually going on.

When you hit a runtime bug, the agent's only tool is "let me add a print statement and restart". That works for simple cases but it's the exact same log-and-restart loop we fall back to in cloud and containerized environments, just with faster typing.

Where it breaks down: timing-sensitive code, Docker services, anything where restarting changes the conditions you need to reproduce.

I've had debugging sessions where the agent burned through 10+ restart cycles on a bug that would've been obvious if it could just watch the live values.

We've given agents the ability to read and write code. We haven't given them the ability to observe running code. That's a pretty big gap.

The one thing I’m not sure about is: does code quality and consistency actually matter? If your architecture is sufficiently modular, you can quickly and inexpensively regenerate any modules whose low quality proves to be problematic.

So, maybe we really are fucked. I don’t know.

A couple "win" examples: add in-text links to every term in this paragraph that appears elsewhere on the page, plus corresponding anchors in the relevant page parts. Or, replace any static text on this page with any corresponding dynamic elements from this reference URL.

Lose examples: constant, but edit format glitches (not matching searched text; even the venerable Opus 4.6 constantly screws this up), unnecessary intermediate variables, ridiculously over-cautious exception-handling, failing to see opportunities to isolate repeated code into a function, or to utilize an existing function that exactly implements said N lines of code, etc.

It seems to me that sadly, paying for getting a few isolated tasks done is becoming a thing of the past.

And then all of a sudden you’re just arguing with the terminal all day - the specs are written by gpt, delivered in-the email written by gpt. Sometimes they dont even have the time to slice their prompt from the edges of the paste but the only thing i can think of is “i need to make the most of 0.5x off peak claude rates “

Fuck.

I got lots of pretty TUIs though so thats neat

Copilot completions are amazingly useful. chatting with the chatbot is a super useful debugging tool. Giving it a function or database query and asking the ai to optimize it works great. But true vibe coding is still, imho, more of a party trick than an actual productivity multiplier. It can do things that look useful, and it can do things that solve immediate self-contained problems. but it can’t create launchable products that serve the needs of multiple users.

I'm enjoying myself so much. Projects I've been thinking about for years are now a couple of hours of hacking around. I'm readjusting my mental model of what's possible as a single developer. And I'm finally learning Go!

The biggest challenge right now is keeping up with the review workload. For low stakes projects (small single-purpose HTML+JS tools for example) I'm comfortable not reviewing the code, but if it's software I plan to have other people use I'm not willing to take that risk. I have a stack of neat prototypes and maybe-production-quality features that I can't ship yet because I've not done that review work.

I mainly work as an individual or with one other person - I'm not working as part of a larger team.

Occasionally I'll catch things it didn't implement at all, or find things like missing permission checks.

We have cursor with essentially unlimited Opus 4.6 and it’s fundamentally changed my workflow as a senior engineer. I find I spend much more time designing and testing my software and development time is almost entirely prompting and reviewing AI changes.

I’m afraid my coding skills are atrophying, in fact I know the are, but I’m not sure if the coding was the part of my job I truly enjoyed. I enjoy thinking higher-level: architecture, connecting components, focusing on the user experience. But I think using these AI tools is a form of golden handcuffs. If I go work at a startup without the money I pay for these models, I think for the first time in my career I would be less likely to be able to successfully code a feature than I could last year.

So professionally there are pros and cons. My design and architecture skills have greatly improved as I am spending more time doing this.

Personally it’s so much fun. I’ve made several side projects I would have never done otherwise. Working with Claude code on greenfield projects is a blast.

...particularly in situations where you might have to navigate a change in jobs and get back to the point where you can reasonably prove that you can program at a professional level (will be interesting to see how/if the interviewing process changes over time due to LLMs).

An example from last week:

Me: Do this.

AI: OK.

<Brings me code that looks like it accomplishes the task but after looking at it it’s accomplishing it in a monkey’s paw/spiteful genie kind of way.>

Me: Not quite, you didn’t take this into account. But I made the same mistake while learning so I can pull it back on track.

AI: OK

<It’s worse, and why are all the values hardcoded now?>

…

40 minutes go by. The simplest, smallest bit of code is almost right.

Me: Alright, abstract it into a Sass mixin.

AI: OK.

<Has no idea how to do it. It installed Sass, but with no understanding of what it’s working on so the mixin implementation looks almost random. Why is that the argument? What is it even trying to accomplish here?>

At which point I just give up and hand code the thing in 10 minutes.

It would be neat if AI worked. It doesn’t.

Treat it like an intern, give it feedback, have it build skills, review every session, make it do unit tests. Red green refactor. Spend time up front reviewing the plan. Clearly communicate your intent and outcomes you want. If you say "do x" it has to guess what you want. If you say "I want this behaviour and this behaviour, 100% branch unit tested, adhearing to contributing guidelines and best practices, etc" it will take a few minutes longer, but the quality increases significantly.

I uninstalled vscode, I built my own dashboard instead that organizes my work. I get instant notifications and have a pr review kick off a highly opinionated or review utilizing the Claude code team features.

If you aren't doing this level of work by now, you will be automated soon. Software engineering is a mostly solved problem at this point, you need to embed your best practices in your agent and keep and eye on it and refine it over time.

I use Claude Opus (4.5, 4.6) all the time and catch it making making subtle mistakes, all the time.

Are you really being more productive (let’s say 3x times more), or just feel that way because you are constantly prompting Claude?

Maybe I’m wrong, but I don’t buy it.

Didn't we make subtle mistakes without AI?

Why did we spend so much time debugging and doing code reviews?

> Are you really being more productive (let’s say 3x times more)

At least 2x more productive, and that's huge.

But since I have a strong rule about always writing unit tests before code, my confidence is a lot higher.

https://simonwillison.net/2025/Dec/18/code-proven-to-work/

I agree that the test harness is the most important part, which is only possible to create successfully if you are very familiar with exactly how your code works and how it should work. How would you reach this point using a dashboard and just reviewing PRs?

I'm talking Claude Opus 4.6 here.

the bottleneck now is testing. that isn't going away anytime soon, it'll get much worse for a bit while models are good at churning code out that's slightly wrong or technically correct, but solving a different problem than intended; it's going to be a relatively short lived situation I'm afraid until the industry switches to most code being written for serving agents instead of humans.

I guess that's why Claude Code has 0 open issues on Github. Since software engineering is solved, their autonomous agents can easily fix their own software much better and faster than human devs. They can just add "make no mistakes" to their prompt and the model can solve any problem!

Oh wait, they have 5,000+ open issues on Github[1]. I'm yet to be convinced that this is a solved problem

[1]: https://github.com/anthropics/claude-code/issues

PS: All in for AI agents I use all the time but sorry - SE is not a solved problem. Yet.

To me, code is both the canvas and deterministic artifact of deep thinking about program logic and data flow, as well as a way to communicate these things to other developers (including myself in the future). Outsourcing that to some statistical amalgam implies that the engineering portion of software engineering is no longer relevant. And maybe it's not for your run-of-the-mill shovelware, but as a profession I'd like to think we hold ourselves to a higher standard than that.

Also, does the sum total of software engineering done up to this point provide a sufficient training set for all future engineering? Are we really "done"? That sounds absurd to me.

I think people spouting absolutist statements like "software engineering is a solved problem" should largely be ignored.

Sincere question, how do beginners to the field (interns, juniors) do this when they don't have any best practices yet?

Unless you want to be a solopreneur (terrible idea while you don't know what you're doing and don't have the means to hire someone that does), look at pretty much any other comment in this thread.

...but since it's so easy to deliver stuff without actually knowing anything, learning means putting in the effort to resist temptation and use the agent as a teaching aid instead of an intern savant.

I don't necessarily disagree with your advice, but goodness, I don't look forward to using any of the low quality software in the next decade. I hope the shareholders remain happy.

??????????

write a thousand md files with detailed prompts (and called them skills)?

is that what would get juniors hired? and paid real money? a stack of md files?

Claude code skills represent a new type of AI native program. Give your agent the file system, let it build tools to sync and manage data.

Gamedev, systems programming, embedded development, 3D graphics, audio programming, mobile, desktop, physics/simulation programming, HPC, RTC, etc.. that’s all solved based on your experience?

It's harder and harder to detect sarcasm these days but in case you're being serious, I've tested a similar setup and I noticed Claude produces perfectly plausible code that has very subtle bugs that get harder and harder to notice. In the end, the initial speedup was gone and I decided to rewrite everything by hand. I'm working on a product where we need to understand the code base very well.

An example I have of this is when I asked Claude to copy a some functionality from a front-end application to a back-end application. It got all of the function signatures right but then hallucinated the contents of the functions. Part of this functionality included a look up map for some values. The new version had entirely hallucinated keys and values, but the values sounded correct if you didn't compare with the original. A human would have literally copied the original lookup map.

But now with Claude, the mental model of how your code works is not in your head, but resides behind a chain of reasoning from Claude Code that you are not privy too. When something breaks, you either have to spend much longer trying to piece together what your agent has made, or to continue throwing Claude at and hope it doesn't spiral into more subtle bugs.

> I mainly work as an individual or with one other person - I'm not working as part of a larger team.

https://github.com/turlockmike

like, we've had this technology for several decades now, and none of these AI tools are like: "This is so great, let me show everyone how to write a CRUD database with a notepad and calendar app" or whatever.

Several decades ago, we barely had the internet, rockets were single use only, and smart phones were coming any day now. CRISPR was yet to be named, social media meant movies from Blockbusters or HBO that you watched with friends. GLP-1 was a meh option for diabetics.

I agree with your overall point but...your time frame is way off.

If AI really is all that, then whatever "special" thing you are doing will be automated as well.

We're discovering so much latent demand for software, Jevon's paradox is in full effect and we're working more than ever with AI (at least I am).

Their comment about people who don't operate like them being out of a job might be true if AI doesn't progress past the current stage but I really don't see progress slowing down, at least in coding models, for quite some time.

So, whatever relevance OPs specific methods have right now will quickly be integrated into the models themselves.

Building AI systems will be about determining the right thing to build and ensuring your AI system fully understands it. For example, I have a trading bot that trades. I spent a lot of time on refining the optimization statement for the AI. If you give it the wrong goal or there's any ambiguity, it can go down the wrong path.

On the back end, I then judge the outcomes. As an engineer I can understand if the work it did actually accomplished the outcomes I wanted. In the future it will be applying that judgement to every field out there.

Though I don't know of any algo trading shop that relies purely on algorithms as market regimes change frequently and the alpha of new edge ends up getting competed away frequently.

(And personally I'm a believer of the jagged intelligence theory of LLMs where there's some tasks that LLMs are great at and other tasks that they'll continue being idiotic at for a while, and think there's plenty of work left for nuts and bolts program writers to do.)

I'll believe it when AI can tell me when a project will be done. I've asked my developer friends about this and I get a blank stare, like I'm stupid for asking.

You from 2 months ago:

>LLMs are great coders, but subpar developers". https://news.ycombinator.com/item?id=46434304

Interesting. That's a lot of progress in 2 months!

In my day job I’m currently a PM/operations director at a small company. We don’t have programmers. I have used AI to build about 12 internal tools in the past year. They’re not very big, but provide huge productivity gains. And although I do not fully understand the codebase, I know what is where. Three of these tools I’m now recreating based on our usage and learnings.

I have learned a ton about all kinds of development concepts in a ridiculously short timeframe.

my team has largely avoided AI; our sister team has been quite gungho on it. i recently handed off a project to them that i'd scoped at about one sprint of work. they returned with a project design that involved four microservices, five new database tables, and an entirely new orchestration and observability layer. it took almost a week of back-and-forth to pare things down.

since then, they've spent several sprints delivering PRs that i now have to review. there's lots of things that don't work, don't make sense, or reinvent things we already have from scratch. almost half the code is dedicated to creating 'reusable' and 'modular' classes (read: boilerplate) for a project that was distinctly scoped as a one-off. as a result, this takes hours, and it's cut into my own sprint velocity. i'm doing all the hard work but receiving none of the credit.

management just told me that every engineer is now required to use AI. i'm tired.

The productivity comes from three main areas for me:

- Having the AI coding assistance write unit tests for my changes. This used to be by far my least favorite part of my job of writing software, mostly because instead of solving problems, it was the monotonous process of gathering mock data to generate specific pathways, trying to make sure I'm covering all the cases, and then debugging the tests. AI coding assistance allows me to just have to review the tests to make sure that they cover all the cases I can think of and that there aren't any overtly wrong assumptions

- Research. It has been extraordinarily helpful in giving me insight into how to design some larger systems when I have extremely specific requirements but don't necessarily have the complete experience to architect them myself - I know enough to understand if the system is going to correctly accomplish the requirements, but not to have necessarily come up with architecture as a whole

- Quick test scripts. It has been extremely useful for generating quick SQL data for testing things, along with quick one-off scripts to test things like external provider APIs

I agree, this is where coding agents really shine for me. Even if they get the details wrong, they often pinpoint where things happen and how quite well.

They're also great for rapid debugging, or assisted bug fixing. Often, I will manually debug a problem, then tell the AI, "This exception occurs in place Y because thing X is happening, here's a stack trace, propose a fix", and then it will do the work of figuring out where to put the fix for me. I already usually know WHAT to do, it's just a matter of WHERE in context. Saves a lot of time.

Likewise, if I have something where I want thing X to do Y, and X already does Z, then I'll say, "Implement a Y that works like Z but for A B C", and it'll usually get it really close on the first try.

On the other hand, I have tried them a number of times in greenfield situations with Python and the web stack and experienced the simultaneous joy and existential dread of others. They can really stand new projects up quick.

As a founder, this leaves me with what I describe as the "generation ship" problem. Is it possible that the architecture we have chosen for my project is so far out of the training data that it would be faster to ditch the project and reimplement it from scratch in a Claude-yolo style? So far, I'm convinced not because the code I've seen in somewhat novel circumstances is fairly mid, but it's hard to shake the thought.

I do find chatting with the models incredibly helpful in all contexts. They are also excellent at configuring services.

If all you're doing is something that already exists but you decided to architecture it in a novel way (for no tangible benefit), then I'd say starting from scratch and make it look more like existing stuff is going to help AI be more productive for you. Otherwise you're on your own unless you can give AI a really good description of what you are doing, how things are tied together etc. And even then it will probably end up going down the wrong path more often than not.

Especially, now that we do have models that can search through code bases.

I feel it made me better and other people worse.

GOOD:

I feel that I’m producing more and better code even with unfamiliar and tangled codebases. For my own side projects, it’s brought them from vague ideas to shipped.

I can even do analyses I never could otherwise. On Friday I converted my extensive unit test suite into a textual simulation of what messages it would show in many situations and caught some UX bugs that way.

Cursor’s Bugbot is genuinely helpful, though it can be irritatingly inconsistent. Sometimes on round 3 with Bugbot it suddenly notices something that was there all along. Or because I touch a few lines of a library suddenly all edge cases in that library are my fault.

NOT GOOD:

The effect on my colleagues is not good. They are not reading what they are creating. I get PRs that include custom circular dependency breakers because the LLM introduced a circular dependency, and decided that was the best solution. The ostensible developer has no idea this happened and doesn’t even know what a circular dependency breaker is.

Another colleague does an experiment to prove that something is possible and I am tasked to implement it. The experiment consists of thousands of lines of code. After I dig into it I realize the code is assuming that something magically happened and reports it’s possible.

I was reflecting on this and realized the main difference between me and my current team is that I won’t commit code I don’t understand. So I even use the LLMs to do refactors just for clarity. while sometimes my colleagues are creating 500-line methods.

Meanwhile our leaders are working on the problem of code review because they feel it’s the bottleneck. They want to make some custom tools but I suspect they are going to be vastly inferior to the tools coming from the major LLM providers. Or maybe we’ll close the loop and we won’t even be reviewing code any more.

What works: I stay in the driver's seat. I own the architecture, make the decisions, validate everything. But I don't need a team to execute — Claude does the implementation. I went from being a solo dev limited by time to running a complex project (multi-agent system, Docker, Synology integration, PHP API) that would normally need 2-3 people.

The key is a good CLAUDE.md file with strict rules, and pushing Claude to think ahead and propose multiple options instead of just doing the first thing that comes to mind. Claude is also surprisingly powerful for audits — security audits, config audits, log analysis.

What doesn't work: it confidently generates plausible-looking code that's subtly wrong. Never trust it on things you can't verify. It also over-engineers everything if you don't rein it in.

The biggest shift: I went from "write code" to "review and direct code." Not sure it's making me a better engineer, but it's making me a more effective one. It extends me.

I have a lot of worry that I will end up having to eventually trudge through AI generated nightmares since the major projects at work are implemented in Java and Typescript.

I have very little confidence in the models' abilities to generate good code in these or most languages without a lot of oversight, and even less confidence in many people I see who are happy to hand over all control to them.

In my personal projects, however, I have been able to get what feels like a huge amount of work done very quickly. I just treat the model as an abstracted keyboard-- telling it what to write, or more importantly, what to rewrite and build out, for me, while I revise the design plans or test things myself. It feels like a proper force multiplier.

The main benefit is actually parallelizing the process of creating the code, NOT coming up with any ideas about how the code should be made or really any ideas at all. I instruct them like a real micro-manager giving very specific and narrow tasks all the time.

Working on projects within a firm is... messy.

Cursor and Claude Code have undoubtedly accelerated certain aspects of my technical execution. In particular, root causing difficult bugs in a complicated codebase has been accelerated through the ability to generate throwaway targeted logging code and just generally having an assistant that can help me navigate and understand complex code.

However, overall I would say that AI coding tools have made my job harder in two other ways:

1. There’s an increased volume of code that requires more thorough review and/or testing or is just generally not in keeping with the overall repo design.

2. The cost is lowered for prototyping ideas so the competitive aspect of deciding what to build or which experiment to run has ramped up. I basically need to think faster and with more clarity to perform the same as I did before because the friction of implementation time has been drastically reduced.

I think it's useful tool, but whenever I have a LLM attempt to develop an entire feature for me, the solution becomes to a pain to maintain (because I don't have the mental model around it or the solution has subtle issues).

Maybe people who are really deep into using AI are using Claude? Perhaps it's way better, I don't know.

The suggestions are correct about 40% of the time, so I'm actually surprised when they're right, rather than becoming reliant on them. It saves me maybe 10 minutes a day.

Fucking robot lol

All I can say for sure is that it is absolutely useful, it has improved my quality of life without a doubt. I stick to the principle that it's here to improve my work life balance, not increase output for our owners.

And that it has done, so far. I can accomplish things that would have taken me weeks of stressful and hyperfocused work in just hours.

I use it very carefully, and sparingly, as a helpful tool in my toolbox. I do not let it run every command and look into every system, just focused efforts to generate large amounts of boilerplate code that would require me to have a lot of docs open if I were to do it myself.

I definitely don't let it read or write my e-mails, or write any text. Because I always loved writing, and will never stop loving it.

It's here to stay, because I'm not alone in feeling this way about it. So the staunch AI-deniers are just wasting their time. Just like any other tech, it's going to be used against humans, against the already oppressed.

I definitely recognize that the tech has made some people lose their minds. Managers and product owners are now vibe coding thinking they can replace all their developers. But their code base will rot faster than they think.

On the other hand I tried to get help debugging a test failure and Claude spit out paragraph after paragraph arguing with itself going back and forth. Not only did it not help none of the intermediate explanations were useful either. It ended up being a waste of time. If I didn't know that I could have easily been sent on multiple wild goose chases.

We use a mix of agentic and conversational tools, just pick your own and go with it.

For Unity development (our main codebase and source of value) I give current gen tools a C- for effectiveness. For solving confined, well modularisable problems (eg refactor this texture loader; implement support for this material extension) it’s good. For most real day to day problems it’s hopelessly confused by the large codebase full of state, external dependency on chunks of Unity, implicit hardware-dependent behaviours, etc. It has no idea how to work meaningfully with Unity’s scene graph or component model. I tried using MCP to empower it here: on a trivial test project it was fine. In a real project it got completely lost and broke everything after eating 30k tokens and 40 minutes of my time, mostly because it couldn’t understand the various (documented) patterns that straddled code files and scene structure.

For web and API development I give it an A, with just a little room for improvement. In this domain it’s really effective all the way down the logical stack from architectural and deployment decisions all the way down to implementation details and debugging including digging really deep in to package version incompatibilities and figuring out problems in seconds that would take me hours. My one criticism would be the - now familiar - “junior developer” effect where it’ll often run ahead with an over engineered lump of machinery without spotting a simpler more coherent pattern. As long as you keep an eye on it it’s fine.

So in summary: if what you’re doing is all in text, nothing in binary, doesn’t involve geometric or numerical reasoning, and has billions of lines of stack overflow solutions: you’ll be golden. Otherwise it’s still very hit and miss.

I write stuff for free. It's definitely "professional grade," and lots of people use the stuff I ship, but I don't earn anything for it.

I use AI every day, but I don't think that it is in the way that people here use it.

I use it as a "coding partner" (chat interface).

It has accelerated my work 100X. The quality seems OK. I have had to learn to step back, and let the LLM write stuff the way that it wants, but if I do that, and perform minimal changes to what it gives me, the results are great.

I'm still learning how to make the most of it but my current state is one of total amazement. I can't believe how well this works now.

One game-changer has been custom agents and agent orchestration, where you let agents kick off other agents and each one is customized and keeps a memory log. This lets me make several 1000 loc features in large existing codebases without reaching context limits, and with documentation that lets me review the work with some confidence.

I have delivered several features in large legacy codebases that were implemented while I attended meetings. Agents have created greenfield dashboards, admin consoles and such from scratch that would have taken me days to do myself, during daily standups. If it turned out bad, I tweaked the request and made another attempt over lunch. Several useful tools have been made that save me hours per week but I never took the time to make myself.

For now, I love it. I do feel a bit of "mourning the craft" but love seeing things be realized in hours instead of days or weeks.

My main work is training Text-to-Speech models, and the friction of experimenting with model features or ideas has dropped massively. If I want to add a new CFG implementation, or conditioning vector, 90% of the time Opus can one-shot it. It generally does a good job of making the model, inference and training changes simultaneously so everything plays nicely. Haven't had any major regressions or missed bugs yet, but we'll see!

The downside is reviewing shitty PRs where it's clear the engineer doesn't fully understand what they're doing, and just a general attitude of "I dunno, Claude suggested it" that's getting pretty exhausting.

Also some not so nice moments (small rust changes were OK, but with a big one claude fumbled + I couldn't really verify that it worked so I didn't merge to code to master even when it seemingly worked)

I think it really helps to break the ice so to say. You no longer feel the tension, the pain of an empty page. You ask claude to write something, and improving something is so mentally easier

Also I mostly use claude as a spell checker / linter for the projects I'm too lazy to install proper tools for that. vim + claude, what else would you need

Luckily my company pays for the subscription, speding personal money on LLMs (especially on US LLMs) would feel strange for some reason. Ideally I want to own an LLM, have it at home but I am too lazy

Important things I've figured out along the way:

1. Enable the agent to debug and iterate. Whatever you'd do to test and verify after you write your first pass at an implementation, figure out a way for an agent to do it too. For example: every API call is instrumented with OpenTelemetry, and the agent has a local collector to query.

2. Make scripts or skills to increase the reliability of fallible multi-step processes that need to be repeated often. For example: getting an oauth token to call some api with the appropriate user scopes for the task.

3. Continually revise your AGENTS.md. I'll often end a coding session by asking the agent whether there's anything from this session that should be captured there. That adds more than it removes, so every few days I'll compact it by having an agent reword the important stuff for conciseness and get rid anything obvious from implementation.

2. Incremental cleanup: I also use it as a fancier upgrade of Visual Studio's Code Analysis feature and aid me in finding areas to refactor.

3. Treating the model as a corpus of prior knowledge and discussions, I can form a 'committee of agents' (Security, Reliability, UX engineer POVs) to help me view my work at a more strategic level.

My additional twist to this is to check against my organization's mission statement. That way, I hope I can help reduce mission drift that I observe was a big issue behind dysfunctional companies.

At least at my company the problem is the business hasn’t caught up. We can code faster but our stakeholders can’t decide what they want us to build faster. Or test faster or grasp new modalities llms make possible.

That’s where I want to go next: not just speeding up and increasing code quality but improving business analytics and reducing the amount of meetings I have to be in to get business problems understood and solved.

"Implement JWT token verification and role checking in Spring Boot. Secure some endpoints with Oauth2, some with API key, some public."

C# and Java are so old, whatever solutions you find are 5 years out of date. Having an agent implement and verify the foundation is the perfect fit. There's no design, just ever-chaning framework magic. I'd do the same "Google and debug" cycle, but 10 times slower.

Terrible idea if you ask me. I'd suggest checking the official docs next time around, or at the very least copying them into the context window.

For my side projects, I do like to offload the tedious steps like setup, scaffolding or updating tasks to Claude. Things like weird build or compile errors that I usually would have to spend hours Googling to figure out I can get sorted in a matter of minutes. Other than that, I still like to write my own code as I enjoy doing it.

Overall, I like it as a tool to assist in my work. What I dislike is how much peddling is being done to shove AI into everything.

I'm lucky enough to have upper management not pressuring to use it this or that way, and I'm using mostly to assist with programming languages/frameworks I'm not familiar with. Also, test cases (these sometimes comes wrong and I need to review thoroughly), updating documentation, my rubber duck, and some other repetitive/time consuming tasks.

Sometimes, if I have a simple, self-contained bug scenario where extensive debug won't be required, I ask it to find the reason. I have a high rate of success here.

However, it will not help you with avoiding anti-patterns. If you introduce one, it will indulge instead of pointing the problem out.

I did give it a shot on full vibe-coding a library into production code, and the experience was successful; I'm using the library - https://youtu.be/wRpRFM6dpuc

I basically don't use AI for coding at all. When I have tried it, it's just half working garbage and trying to describe what I want in natural language is just miserable. It feels like trying to communicate via smoke signals.

I'll be a classical engineer until they fire me and then go do something else. So far, that's working. We've had multiple rounds of large layoffs in the last year and somehow I'm still here.

I also use it as a final check on all my manually written code before sending it for code review.

With all that said, I have this weird feeling that my ability to quickly understand and write code is no longer noticeable, nor necessary.

Everyone now ships tons of code and even if I do the same without any LLM, the default perception will be that it has been generated.

I am not depressed about it yet, but it will surely take a while to embrace the new reality in its entirety

Makes a late night oncall page way easier when the bot will tell you exactly what broke

When it comes to personal projects I'm feeling extremely unmotivated. Things feel more in reach and I've probably built ten times the number of throwaway projects in the past year than I have in previous years. Yet I feel no inspiration to see those projects through to the end. I feel no connection to them because I didn't build them. I have a feeling of 'what's the point' publishing these projects when the same code is only a few prompts away for someone else too. And publishing them under my name only cheapens the rest of my work which I put real cognitive effort into.

I think I want to focus more on developing knowledge and skills moving forward. Whatever I can produce with an LLM in a few hours is not actually valuable unless I'm providing some special insight, and I think I'm coming to terms with that at the moment.

For me, this is a key differentiator between “AI-assisted” and “vibe-coded”. With the former, I may use AI in many ways: some code generation, review, bouncing ideas, or whatever. But I engage in every step, review and improve the generated code, disagree with the reviews (and still contribute a good proportion of hand-written code, at least in the core business logic). In this way I retain sufficient ownership over the output to feel it is my own.

With vibe-coding, I feel exactly as you describe it.

This is a key candidates to use AI as we have built hundreds of warehouses in the past. We have a standard product that spans over a hundred thousand lines of code to build upon. Still, we rely on copying code from previous projects if features have been implemented before. We have stopped investing in the product to migrate everything to microservices, for some reason, so this code copying is increasingly common as projects keep getting more complex.

Teams to implement warehouses are generally around eight developers. We are given a design spec to implement, which usually spans a few hundred pages.

AI has over doubled the speed at which I can write backend code. We've done the same task so many times before with previous warehouses, that we have a gold mine of patterns that AI can pick up on if we have a folder of previous projects that it can read. I also feel that the code I write is higher quality, though I have to think more about the design as previously I would realize something wouldn't work whilst writing the code. At GWT though, it's hopeless as there's almost no public GWT projects to train an AI on. It's also very helpful in tracing logs and debugging.

We use Cursor. I was able to use $1,300 tokens worth of Claude Opus 4.6 for a cost of $100 to the company. Sadly, Cursor discontinued it's legacy pricing model due to it being unsustainable, so only the non-frontier models are priced low enough to consistently use. I'm not sure what I'm going to do when this new pricing model takes affect tomorrow, I guess I will have to go back to writing code by hand or figure out how to use models like Gemini 3.1. GPT models also write decent code, but they are always so paranoid and strictly follow prompts to their own detriment. Gemini just feels unstable and inconsistent, though it does write higher quality code.

I'm not being paid any more for doubling my output, so it's not the end of the world if I have to go back to writing code by hand.

So far, it's been fantastic. I can do more things for clients, much faster, than I ever dreamed would be possible when I've attempted work like this before.

I think the biggest problem with AI coding is that it simply doesn't fit well into existing enterprise structures. I couldn't imagine being able to do anything productive when I'm stuck having to rely on other teams or request access to stuff from the internet like I did in previous jobs.

It is great for getting an overview on a pile of code that I'm not familiar with.

It has debugged some simple little problems I've had, eg, a complex regex isn't behaving so I'll give it the regex and a sample string and ask, "why isn't this matching" and it will figure out out.

I've used it only a little for writing new code. In those cases I will write the shell of a subroutine and a comment saying what the subroutine takes in and what it returns, then ask the LLM to fill in the body. Then I review it.

It has been useful for translating ancient perl scripts into something more modern, like python.