Ask HN: How is AI-assisted coding going for you professionally?

It’s a fantastic performance booster for a lot of mundane tasks like writing and revising design docs, tests, debugging (using it like a super smart and active rubber duck), and system design discussions.

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

I’ve been a web dev for 10+ years, and my professional pivot in 2026 has been moving away from "content-first" sites to "tool-led" content products. My current stack is Astro/Next.js + Tailwind + TypeScript, with heavy Python usage for data enrichment.

What’s working:

Boilerplate & Layout Shifting: AI (specifically Claude 4.x/5) is excellent for generating Astro components and complex Tailwind layouts. What used to take 2 hours of tweaking CSS now takes 15 minutes of prompt-driven iteration.

Programmatic SEO (pSEO) Analysis: I use Python scripts to feed raw data into LLMs to generate high-volume, structured analysis (300+ words per page). For zero-weight niche sites, this has been a massive leverage point for driving organic traffic.

Logic "Vibe Checks": When building strategy engines (like simulators for complex games), I use AI to stress-test my decision-making logic. It’s not about writing the core engine—which it still struggles with for deep strategy—but about finding edge cases in my "Win Condition" algorithms.

The Challenges:

The "Fragment" Syntax Trap: In Astro specifically, I’ve hit issues where AI misidentifies <> shorthand or hallucinates attribute assignments on fragments. You still need to know the spec inside out to catch these.

Context Rot: As a project grows, the "context window" isn't the problem; it's the "logic drift." If you let the AI handle too many small refactors without manual oversight, the codebase becomes a graveyard of "almost-working" abstractions.

The Solution: I treat AI as a junior dev who is incredibly fast but lacks a "mental model" of the project's soul. I handle the architecture and the "strategy logic," while the AI handles the implementation of UI components and repetitive data transformations.

Stack: Astro, TypeScript, Python scripts for data. Experience: 10 years, independent/solo.

I am having the greatest time professionally with AI coding. I now have the engineering team I’ve always dreamed of. In the last 2 months I have created:

- a web-based app for a F500 client for a workflow they’ve been trying to build for 2 years; won the contract

- built an iPad app for same client for their sales teams to use

- built the engineering agent platform that I’m going to raise funding

- a side project to do rough cuts of family travel videos (https://usefirstcut.com, soft launch video: https://x.com/xitijpatel/status/2026025051573686429)

I see a lot of people in this thread struggling with AI coding at work. I think my platform is going to save you. The existing tools don’t work anymore, we need to think differently. That said, the old engineering principles still work; heck, they work even better now.

As crazy as this seems, it's unlocking another variation of software engineering I didn't think was accessible. Previously, super entrenched and wicked expensive systems that might have taken years of engineering effort, appear to be ripe for disruption suddenly. The era of software systems with deeply engineered connectivity seem to be on the outs...

For asking quick questions that would normally send me to a search engine, it’s pretty helpful. It’s also decent (most of the time) and throwing together some regex.

For throw away code, I might let the agent do some stuff. For example, we needed to test timing on DNS name resolution on a large number of systems to try and track down if that was causing our intermittent failures. I let an agent write that and was able to get results faster than if I did it myself, and I ultimately didn’t have to care about the how… I just needed something to show to the network team to prove it was their problem.

For larger projects that need to plugin to the legacy code base, which I’ll need to maintain for years, I still prefer to do things myself, using AI here and there as previously mentioned to help with little things. It can also help finding bugs more quickly (no more spending hours looking for a comma).

I had an agent refactor something I was making for a larger project. It did it, and it worked, but it didn’t write it in a way that made sense to my brain. I think others on my team would have also had trouble supporting it too. It took something relatively simple and added so many layers to it that it was hard to keep all the context in my head to make simple edits or explain to someone else how it worked. I might borrow some of the ideas it had, but will ultimately write my own solution that I think will be easier for other people to read and maintain.

Borrowing some of these ideas and doing it myself also allows me to continue to learn and grow, so I have more tools in my tool belt. With the DNS thing that was totally vibe coded, there were some new things in there I hadn’t done before. While the code made sense when I skimmed through it, I didn’t learn anything from that effort. I couldn’t do anything it did again without asking AI to do it again. Long-term, I think this would be a problem.

Other people on my team have been using AI to write their docs. This has been awful. Usually they don’t write anything at all, but at least then I know they didn’t writing anything. The AI docs are simply wrong, 100% hallucinations. I have to waste time checking the doc against the code to figure that out and then go to the person that did it to make them fix it. Sometimes no doc is better than a bad doc.

Models aren’t reliable, and it’s a bottleneck.

My solution was to write code to force the model down a deterministic path.

It’s open source here: https://codeleash.dev

It’s working! ~200k LOC python/typescript codebase built from scratch as I’ve grown out the framework. I probably wrote 500-1000 lines of that, so ~99.5% written by Claude Code. I commit 10k-30k loc per week, code-reviewed and industrial strength quality (mainly thanks to rigid TDD)

I review every line of code but the TDD enforcement and self-reflection have now put both the process and continual improvement to said process more or less on autopilot.

It’s a software factory - I don’t build software any more, I walk around the machine with a clipboard optimizing and fixing constraints. My job is to input the specs and prompts and give the factory its best chance of producing a high quality result, then QA that for release.

I keep my operational burden minimal by using managed platforms - more info in the framework.

One caveat; I am a solo dev; my cofounder isn’t writing code. So I can’t speak to how it is to be in a team of engineers with this stuff.

Like a lot of things, it’s neither and somewhere in the middle. It’s net useful even if just for code reviews that make you think about something you may have missed. I personally also use it to assist in feature development, but it’s not allowed to write or change anything unless I approve it (and I like to look at the diff for everything)

We're using Augment Code heavily on a "full rewrite of legacy CRM with 30 years of business rules/data" Laravel project with a team size of 4. Augment kind of became impossible to avoid once we realized the new guy is outpacing the rest of us while posessing almost no knowledge of code and working fully in the business requirements domain, extracting requirements from the customer and passing them to AI, which was encoding them in tests and implementing them in code.

I'm using `auggie` which is their CLI-based agentic tool. (They also have a VS Code integration - that became too slow and hung often the more I used it.) I don't use any prompting tricks, I just kind of steer the agent to the desired outcome by chatting to it, and switch models as needed (Sonnet 4.6 for speed and execution, GPT 5.1 for comprehension and planning).

My favorite recent interaction with Augment was to have one session write a small API and its specification within the old codebase, then have another session implement the API client entirely from the specification. As I discovered edge cases I had the first agent document them in the spec and the second agent read the updated spec and adjust the implementation. That worked much, much better than the usual ad hoc back and forth directly between me and one agent and also created a concise specification that can be tracked in the repo as documentation for humans and context for future agentic work.

It’s going very well.

Experience level: very senior, programming for 25 years, have managed platform teams at Heroku and Segment.

Project type: new startup started Jan ‘26 at https://housecat.com. Pitch is “dev tools for non developers”

Team size: currently 2.

Stack: Go, vanilla HTML/CSS/JS, Postgres, SQLite, GCP and exe.dev.

Claude code and other coding harnesses fully replaced typing code in an IDE over the past year for me.

I’ve tried so many tools. Cursor, Claude and Codex, open source coding agents, Conductor, building my own CLIs and online dev environments. Tool churn is a challenge but it pays dividends to keep trying things as there have been major step functions in productivity and multi tasking. I value the HN community for helping me discover and cut through the space.

Multiple VMs available over with SSH with an LLM pre-configured has been the latest level up.

Coding is still hard work designing tests, steering agents, reviewing code, and splitting up PRs. I still use every bit of my experience every day and feel tired at end of day.

My non-programmer co-founder, more of a product manager and biz ops person, has challenges all the time. He generally can only write functional prototypes. We solve this by embracing the functional prototype and doing a lot of pair programming. It is much more productive than design docs or Figma wireframes.

In general the game changer is how much a couple of people can get done. We’re able to prototype ideas, build the real app, manage SOC2 infra, marketing and go to market better than ever thanks to the “willing interns” we have. I’ve done all this before and the AI helps with so much of the boilerplate and busywork.

I’m looking for beta testers and security researchers for the product, as well as a full time engineer if anyone is interested in seeing what a “greenfield” product, engineering culture and business looks like in 2026. Contact info in my profile.

Two contexts:

1. Workplace, where I work on a lot of legacy code for a crusty old CRM package (Saleslogix/Infor), and a lot of SQL integration code between legacy systems (System21).

So far I've avoided using AI generated code here simply because the AI tools won't know the rules and internal functions of these sets of software, so the time wrangling them into an understanding would mitigate any benefits.

In theory where available I could probably feed a chunk of the documentation into an agent and get some kind of sensible output, but that's a lot of context to have to provide, and in some cases such documentation doesn't exist at all, so I'd have to write it all up myself - and would probably get quasi hallucinatory output as a reward for my efforts.

2. Personally where I've been working on an indie game in Unity for four years. Fairly heavy code base - uses ECS, burst, job system, etc. From what I've seen AI agents will hallucinate too much with those newer packages - they get confused about how to apply them correctly.

A lot of the code's pretty carefully tuned for performance (thousands of active NPCs in game), which is also an area I don't trust AI coding at all, given it's a conglomeration of 'average code in the wild that ended up in the training set'.

At most I sometimes use it for rubber ducking or performance. For example at one point I needed a function to calculate the point in time at which two circles would collide (for npc steering and avoidance), and it can be helpful to give you some grasp of the necessary math. But I'll generally still re-write the output by hand to tune it and make sure I fully grok it.

Also tried to use it recently to generate additional pixel art in a consistent style with the large amount of art I already have. Results fell pretty far short unfortunately - there's only a couple of pixel art based models/services out there and they're not up to snuff.

I'm enjoying it. At this stage though, I just don't see much value if you don't have any prior knowledge of what you're doing. Of course you can use LLMs to get better at it but we're not yet at the point where I'd trust them to build something complex without supervision... nor is anyone suggesting that, except AI CEOs :)

I do wonder what will happen when real costs are billed. It might end up being a net positive since that will make you think more about what you prompt, and perhaps the results will be much better than lazily prompting and seeing what comes out (which seems to be a very typical case).

Right now I enjoy the labs' cli harnesses, Claude Code, and Codex (especially for review). I do a bunch of niche stuff with Pi and OpenCode. My productivity is up. Some nuances with working with others using the same AI tools- we all end up trying to boil the ocean at first- creating a ton of verbose docs and massive PRs, but I/they end up regressing on throwing up every sort of LLM output we get. Instead, we continously refine the outputs in a consumable+trusted way.

My workday is fairly simple. I spend all day planning and reviewing.

1. For most features, unless it's small things, I will enter plan mode.

2. We will iterate on planning. I built a tool for this, and it seems that this is a fairly desired workflow, given the popularity through organic growth. https://github.com/backnotprop/plannotator

  - This is a very simple tool that captures the plan through a hook (ExitPlanMode) and creates a UI for me to actually read the plan and annotate, with qol things like viewing plan diffs so I can see what the agent changed.

4. Do a lot of this / multitasking with worktrees now.

Worktrees weren't something I truly understood the value of for a while, until a couple weeks ago, embarrassingly enough: https://backnotprop.com/blog/simplifying-git-worktrees/

It allowed me to build my SaaS https://agreezy.app in 2 months (started January and launched early February). A lot of back and forth between Claude and Qwen but it's pretty polished. AI hallucinations are real so I ended up more tests than normal.

Same attitudes as others in this thread.

For personal projects and side company, I get to join in on some of the fun and really multiply the amount of work I can get through. I tend to like to iterate on a project or code base for awhile, thinking about it and then tearing things down and rebuilding it until I arrive at what I think is a good implementation. Claude Code has been a really great companion for this. I'd wager that we're going to see a new cohort of successful small or solo-founder companies that come around because of tools like this.

For work, I would say 60% of my company's AI usage is probably useless. Lots of churning out code and documents that generate no real value or are never used a second time. I get the sense that the often claimed "10x more productive" is not actually that, and we are creating a whole flood of problems and technical debt that we won't be able to prompt ourselves out of. The benefit I have mostly seen myself so far is freeing up time and automating tedious tasks and grunt work.

It churns through boring stuff but it's like I imagine the intellectual equivalent of breaking in a wild horse at times, so capable, so fast but easy to find yourself in a pile on the floor.

I'm learning all the time and it's fun, exasperating, tremendously empowering and very definitely a new world.

I use it mostly to explore the information space of architectural problems, but the constant "positive engagement feedback" (first line of each generation "brilliant insight") start being deeply insincere and also false by regularly claiming "this is the mathematically best solution - ready to implement ?" only that it isn't when considering it truly.

I have moved away from using an LLM now before having figured out the specifications, otherwise it's very very risky to go down a wrong rabbit hole the LLM seduced you into via its "user engagement" training.

It's going pretty well, though it took at least six months to get there. I'm helped by knowing the domain reasonably well, and working with a principal investigator who knows it well and who uses LLMs with caution. At this stage I use Claude for coding and research that does not involve sensitive matters, and local-only LLMs for coding and research that does. I've gradually developed some regular practices around careful specification, boundaries, testing, and review, and have definitely seen things go south a few times. Used cautiously, though, I can see it accelerating progress in carefully-chosen and -bounded work.

At my FAANG, there was a team of experienced engineers that proved they could deliver faster and more performant code than a complete org that was responsible for it earlier.

So now a lot of different parts of the company are trying to replicate their workflow. The process is showing what works, you need to have AI first documentation (readme with one line for each file to help manage context), develop skills and steering docs for your codebase, code style, etc,. And it mostly works!

For me personally, it has drastically increased productivity. I can pick up something from our infinitely huge backlog, provide some context and let the agent go ham on fixing it while i do whatever other stuff is assigned to me.

The biggest win for me has been cross-stack context switching. I maintain services in TypeScript, Python, and some Go, and the cost of switching between them used to be brutal - remembering idioms, library APIs, error handling patterns. Now I describe what I need and get idiomatic code in whichever language I'm in. That alone probably saves me 30-40 minutes on a typical day.

Where it consistently fails: anything involving the interaction between systems. If a bug spans a queue producer and its consumer, or the fix requires understanding how a frontend state change propagates through API calls to a cache invalidation - the model gives you a confident answer that addresses one layer and quietly ignores the rest. You end up debugging its fix instead of the original issue.

My stack: Claude Code (Opus) for investigation and bug triage in a ~60k LOC codebase, Cursor for greenfield work. Dropped autocomplete entirely after a month - it interrupted my thinking more than it helped.

I just wonder if there are comments in this thread from anthropic bots, marketing itself

At work I mostly use claude code and chatgpt web for general queries, but cursor is probably the most popular in our company. I don’t think we are "cooked" but it definitely changes how development will be done. I think the process of coming up with solutions will still be there but implementation is much faster now.

My observations:

1. What works for me is the usual, work iteratively on a plan then implement and review. The more constraints I put into the plan the better.

2. The biggest problem for me is LLM assuming something wrong and then having to steer it back or redoing the plan.

3. Exploring and onboarding to new codebases is much faster.

4. I don’t see the 10x speedup but I do see that now I can discard and prototype ideas quickly. For example I don’t spend 20-30 minutes writing something just to revert it if I don’t like how it looks or works.

5. Mental exhaustion when working on multiple different projects/agent sessions is real, so I tend to only have one. Having to constantly switch mental model of a problem is much more draining than the “old” way of working on a single problem. Basically the more I give in into vibing the harder it is to review and understand.

At $WORK, my team is relatively small (< 10 people) and a few people really invested in getting the codebase (a large Elixir application with > 3000 modules) in shape for AI-assisted development with a very comprehensive set of skills, and some additional tooling.

It works really well (using Claude Code and Opus 4.6 primarily). Incremental changes tend to be well done and mostly one-shotted provided I use plan mode first, and larger changes are achievable by careful planning with split phases.

We have skills that map to different team roles, and 5 different skills used for code review. This usually gets you 90% there before opening a PR.

Adopting the tool made me more ambitious, in the sense that it lets me try approaches I would normally discard because of gaps in my knowledge and expertise. This doesn't mean blindly offloading work, but rather isolating parts where I can confidently assess risk, and then proceed with radically different implementations guided by metrics. For example, we needed to have a way to extract redlines from PDF documents, and in a couple of days went from a prototype with embedded Python to an embedded Rust version with a robust test oracle against hundreds of document.

I don't have multiple agents running at the same time working on different worktrees, as I find that distracting. When the agent is implementing I usually still think about the problem at hand and consider other angles that end up in subsequent revisions.

Other things I've tried which work well: share an Obsidian note with the agent, and collaboratively iterate on it while working on a bug investigation.

I still write a percentage of code by hand when I need to clearly visualise the implementation in my head (e.g. if I'm working on some algo improvement), or if the agent loses its way halfway through because they're just spitballing ideas without much grounding (rare occurrence).

I find Elixir very well suited for AI-assisted development because it's a relatively small language with strong idioms.

I've shipped full features and bug fixes without touching an IDE for anything significant.

When I need to type stuff myself it's mostly just minor flavour changes like Claude adding docstrings in a silly way or naming test functions the wrong way - stuff that I fixed in the prompt for the next time.

And yes, I read and understand the code produced before I tag anyone to review the PR. I'm not a monster =)

I use it as a research tool.

What it has done is replace my Googling and asking people looking up stuff on stack over flow.

Its also good for generating small boiler plate code.

I don't use the whole agents thing and there are so many edge cases that I always need to understand & be aware of that the AI honestly think cannot capture

I am no longer in software as a day job so i am not sure of my input applys. I traded that world for opening a small brewery back in 2013. So I am a bit outdated on many modern trends but I still enjoy programming. In the last fee months using both gemeni and now movong over to claude, I have created at least 5 (and growing) small apps that have radically transformed what i am able to do at the business. I totally improved automation of my bookkeeping (~16hrs a month categorizing everything down to 3ish), created an immense amount of better reports on production, sales and predictions from a system i had already been slowly writing all these years, I created a run club rewards tracking app instead of relying on our paper method, improved upon a previously written full tv menu display system that syncs with our website and on premis tvs and now i am working on a full productive maintenance trigger system and a personal phone app to trigger each of these more easily. Its been a game changer for me. I have so many more ideas planned and each one frees up more of my waste time to create more.

I just moved to a new team in my company that prides itself on being "AI-First". The work is a relatively new project that was stood up by a small team of two developers (both of whom seem pretty smart) in the last 4 months. Both acknowledged that some parts of their tech stack, they just don't at all understand (next.js frontend). The backend is a gigantic monorepo of services glued together.

The manager & a senior dev on my first day told me to "Don't try to write code yourself, you should be using AI". I got encouraged to use spec-driven development and frameworks like superpowers, gsd, etc.

I'm definitely moving faster using AI in this way, but I legitimately have no idea what the fuck I am doing. I'm making PRs I don't know shit about, I don't understand how it works because there is an emphasis on speed, so instead of ramping up in a languages / technologies I've never used, I'm just shipping a ton of code I didn't write and have no real way to vet like someone who has been working with it regularly and actually has mastered it.

This time last year, I was still using AI, but using it as a pair programming utility, where I got help learn to things I don't know, probe topics / concepts I need exposure to, and reason through problems that arose.

I can't control the direction of how these tools are going to evolve & be used, but I would love if someone could explain to me how I can continue to grow if this actually is the future of development. Because while I am faster, the hope seems to be AI / Agents / LLMs will only ever get better and I will never need to have an original thought or use crtical thinking.

I have just about 4 years of professional experience. I had about 10 - 12 months of the start of my career where I used google to learn things before LLMs became sole singular focus.

I wake up every day with existential dread of what the future looks like.

Pretty good, we have a huge number of projects, some more modern than others. For the older legacy systems, it's been hugely useful. Not perfect, needs a bit more babysitting, but a lot easier to deal with than doing it solo. For the newer things, they can mostly be done solely by AI, so more time spent just speccing / designing the system than coding. But every week we are working out better and batter ways of working with AI, so it's an evolving process at the moment

So I am a software engineer at Microsoft, so we have been using the Github Copilot very regularly. It gives us unlimited Opus credits.

The good thing is that the work gets much quicker than before, and it's actually a boon for that

The issue is inflated expectations

For example: If a work item ideally would take two weeks before AI, it is expected now to be done in like 2 days.

So we still need to find a sweet spot so that the expectations are not unbelievable.

MS is a mature place so they're still working on it and take our feedback seriously. at least that's what I have seen

I find it useful. It has been a big solve from a motivation perspective. Getting into bad API docs or getting started on a complex problem, it's easy to have AI go with me describing it. And the other positive is front end design. I've always hated css and it's derivatives and AI makes me now decent.

The negatives are that AI clearly loves to add code, so I do need to coach it into making nice abstractions and keeping it on track.

I am required to maximise my use of AI at work and so I do. It's good enough at simple, common stuff. Throw up a web page, write some python, munge some data in C++, all great as long as the scale is small. If I'm working on anything cutting edge or niche (which I usually am) then it makes a huge mess and wastes my time. If you have a really big code base in the ~50million loc range then it makes a huge mess.

I really liked writing code, so this is all a big negative for me. I genuinely think we have built a really bad thing, that will take away jobs that people love and leave nothing but mediocrity. This thing is going to make the human race dumber and it's going to hold us back.

I am having a blast at work. I've been leaning hard into AI (as directed by leadership) while others are falling far far behind. I am building new production features, often solo or with one or two other engineers, at lightning speed, and being recognized across the org for it. This is an incredible opportunity for many engineers that won't last. I'm trying to make the most of it. It will be sad when software is no longer a useful pastimes for humans. I'm thinking another three years and most of us will be unemployed or our jobs will have been completely transformed into something unrecognizable a few short years ago.

Daily Claude user via Cursor.

What works:

-Just pasting the error and askig what's going on here.

-"How do I X in Y considering Z?"

-Single-use scripts.

-Tab (most of the time), although that doesn't seem to be Claude.

What doesn't:

-Asking it to actually code. It's not going to do the whole thing and even if, it will take shortcuts, occasionally removing legitimate parts of the application.

-Tests. Obvious cases it can handle, but once you reach a certain threshold of coverage, it starts producing nonsense.

Overall, it's amazing at pattern matching, but doesn't actually understand what it's doing. I had a coworker like this - same vibe.

I only just started using it at work in the last month.

I am a data engineer maintaining a big data Spark cluster as well as a dozen Postgres instances - all self hosted.

I must confess it has made me extremely productive if we measure in terms of writing code. I don't even do a lot of special AGENTS.md/CLAUDE.md shenanigans, I just prompt CC, work on a plan, and then manually review the changes as it implements it.

Needless to say this process only works well because: A) I understand my code base. B) I have a mental structure of how I want to implement it.

Hence it is easy to keep the model and me in sync about what's happening.

For other aspects of my job I occasionally run questions by GPT/Gemini as a brainstorming partner, but it seems a lot less reliable. I only use it as a sounding board. I does not seem to make me any more effective at my job than simply reading documents or browsing github issues/stack overflow myself.

On two greenfield web apps using straightforward stuff (Preact, Go, PostgreSQL) Claude Code has been very helpful. Especially with Claude Code and Opus >= 4.5, adding an incremental feature mostly just works. One of these is sort of a weird IDE, and Opus even does OK with obscureish things like CodeMirror grammars. I literally just write a little paragraph describing what I want, have it write the code and tests, give it a quick review, and 80% of the time it’s like, great, no notes.

To be clear, this is not vibecoding. I have a strong sense of the architecture I want, and explicitly keep Claude on the desired path much like I would a junior programmer. I also insist on sensible unit and E2E test coverage with every incremental commit.

I will say that after several months of this the signalling between UI components is getting a bit spaghettilike, but that would’ve happened anyway, and I bet Claude will be good at restructuring it when I get around to that.

I also work in a giant Rails monolith with 15 years of accumulated cruft. In that area, I don’t write a whole lot, but CC Opus 4.6 is fantastic for reading the code. Like, ask “what are all the ways you can authenticate an API endpoint?” and it churns away for 5 minutes and writes a nice summary of all four that it found, what uses them, where they’re implemented, etc.

It is definitely making me more productive.

Tasks where, in the past, I have thought “if I had a utility to do x it would save me y time” and I’d either start and give up or spend much longer than y on it are now super easy, create a directory, claude “create an app to do x” so simple.

I am forced to use it. They want us to only have code written by Claude. We are forced to use spec-kit for everything so every PR has hundreds, if not thousands, of lines of markdown comitted to the repo per ticket. I basically only review code now. It changes so fast it is impossible to have a stable mental model of the application. My job is now to goto meetings, go through the motions of reviewing thousands of lines of slop per day while sending thousands of lines of slop to others. Everything I liked about the job has been stolen from me, only things I disliked or was indifferent to are left.

If this is what the industry is now… this will be my last job in it.

Curse everyone involved with creating this nightmare.

Using Claude Code professionally for the last 2 months (Max plan) at Rhoda AI and love it!

Software Engineering has never been more enjoyable.

Python, C++, Docker, ML infra, frontend, robotics software

I have 5 concurrent Claude Code sessions on the same mono repo.

Thank you Anthropic!

AI is great for getting stuff to work on technologies you're not familiar with. E.g. to write an Android or iOS app or an OpenGL shader, or even a Linux driver. It's also great for sysadmin work such as getting an ethernet connection up, or installing a docker container.

For main coding tasks, it is imho not suitable because you still have to read the code and I hate reading other people's code.

And also, the AI is still slow, so it is hard to stay focused on a task.

I work in HPC and I’ve found it very useful in creating various shell scripts. It really helps if you have linters such as shellcheck.

Other areas of success have been just offloading the typing/prototyping. I know exactly how the code should look like so I rarely run into issues.

my team is anti-AI. my code review requests are ignored, or are treated more strictly than others. it feels coordinated - i will have to push back the launch date of my project as a result.

another teammate added a length check to an input field, and his request was merged near instantly, even though it had zero unit testing. this team is incredibly cooked in the long term, i just need to ensure that i survive the short term somehow.

It's been great - I work on a lot of projects that are essentially prototypes, to test out different ideas. It's amazing for this - I can create web apps in a day now, which in the past I would not have been able to create at all, as I spent most of my career on the backend.

I've been working on a client server unity based game the last couple of years. It's pretty bad at handling that use case. It misses tons of corner cases that span the client server divide.

AI-assisted research is a solid A already. If you are doing greenfield then. The horizon is only blocked by the GUI required tooling. Even then, that is a small enough obstruction for most researchers.

I'm a manager at a large consumer website. My team and I have built a harness that uses headless Claude's (running Opus) to do ticket work, respond to and fix PR comments, and fix CI test failures. Our only interaction with code is writing specs in Jira tickets (which we primarily do via local Claudes) and adding PR comments to GitHub PRs.

The speed we can move at is astounding. We're going to finish our backlog next quarter. We're conservatively planning on launching 3x as many features next quarter.

Claude is far from perfect: it's made us reassess our coding standards since code is primarily for Claude now, not for humans. So much of what we did was to make code easier for the next dev, and that just doesn't matter anymore.

I enjoy Opus on personal projects. I don’t even bother to check the code. Go/JavaScript/Typescript/CSS works very well for me. Swift not so much. I haven’t tried C/C++ yet. Scala was Ok.

Professionally I hardly use the tools for coding, since I’m in an architecture role and mostly write design docs and do reviews. And I write the occasional prototype.

I have started building tools to integrate copilot (Opus) better with $CORP. This way I can ask it questions across confluence and github.

Leveraging Claude for a project feels very addictive to me. I have to make a conscious effort to stop and I end up working on multiple projects at the same time.

Very hit or miss.

Stack: go, python Team size: 8 Experience, mixed.

I'm using a code review agent which sometimes catches a critical big humans miss, so that is very useful.

Using it to get to know a code base is also very useful. A question like 'which functions touch this table' or 'describe the flow of this API endpoint' are usually answered correctly. This is a huge time saver when I need to work on a code base i'm less familiar with.

For coding, agents are fine for simple straightforward tasks, but I find the tools are very myopic: they prefer very local changes (adding new helper functions all over the place, even when such helpers already exist)

For harder problems I find agents get stuck in loops, and coming up with the right prompts and guardrails can be slower than just writing the code.

I also hates how slow and unpredictable the agents can be. At times it feels like gambling. Will the agents actually fix my tests, or fuck up the code base? Who knows, let's check in 5 minutes.

IMO the worst thing is that juniors can now come up with large change sets, that seem good at a glance but then turn out to be fundamentally flawed, and it takes tons of time to review

It's useful. At my company we have an internal LLM that tends to be used in lieu of searching the web, to avoid unintentionally leaking information about what we are working on to third parties. This includes questions about software development, including generating of code. For various reasons we are not permitted to copy this verbatim, but can use it for guidance - much like, say, inspiration from Stack Overflow answers.

My current employer is taking a long time to figure out how they think they want people to use it, meanwhile, all my side projects for personal use are going quite strong.

Originally my workflow was:

- Think about requirement

- Spend 0-360 minutes looking through the code

- Start writing code

- Realize I didn't think about it quite enough and fix the design

- Finish writing code

- Write unit tests

- Submit MR

- Fix MR feedback

Until recently no LLM was able to properly disrupt that, however the release of Opus 4.5 changed that.

Now my workflow is:

- Throw as much context into Opus as possible about what I want in plan mode

- Spend 0-60 minutes refining the plan

- Have Opus do the implementation

- Review all the code and nitpick small things

- Submit MR

- Implement MR feedback

Running faster does not mean anything unless you know where you are going.