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.

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.

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.

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 quit my job and went out on my own freelancing.

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.

Hating it TBH. I feel like it took away a lot of what I enjoyed about programming but its often so effective and I'm under so much pressure to be fast that I can't not use it.

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.

Couldn’t read the entire comments but, my experience has been overwhelmingly positive so far. I think what helps me be effective is a combination of factors: I work only in a modern, well-documented and well-architected Java codebase with over 80% test coverage.

I only use Claude Code with Opus 4.6 on High Effort.

I always, ALWAYS treat my “new job” as writing a detailed ticket for whatever it is I need to do.

I give the model access to a DB replica of my prod DB that I create manually.

I do NOT waste time with custom agents, Claude.md files or any of that stuff.

When I put ALL of the above together, the results ARE THE PROMISED LAND: I simply haven’t written a single line of code manually in the last 3 months.

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

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.