Define "professional."

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.

For my specific niche (medical imaging) all current models still suck. The amount of expert knowledge required to understand the data and display it in the right way - probably never was in the training set.

We have this one performance-critical 3D reconstruction engine part, that just just has to go FAST through billions of voxels. From time to time we try to improve it, by just a bit. I have probably wasted at least 2 full days with various models trying out their suggestions for optimizations and benchmarking on real-world data. NONE produced an improvement. And the suggested changes look promising programming-wise, but all failed with real-world data.

These models just always want to help. Even if there is just no way to go, they will try to suggest something, just for the sake of it. I would just like the model to say "I do not know", or "This is also the best thing that I can come up with"... Niche/expert positions are still safe IMHO.

On the other hand - for writing REST with some simple business logic - it's a real time saver.

I develop prototypes using Claude Code. The dead boring stuff.

"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.

I don’t use AI to generate any code, but I have used a few tools sparingly as such:

1. Gemini as a replacement for Stack Overflow, but I always have to check the source because it sometimes gives examples that 10 or even 15+ years old, as if that’s a definitive answer. We cannot and should not trust that anything AI produces is correct.

2. Co-Pilot to assist in code snippets and suggestions, like a better Intellisense. Comes in handy for CLI tools such as docker compose, etc.

3. Co-Pilot to help comprehension of a code base. For example, to ask how a particular component works or to search for the meaning of a term of reference to it, especially if the term is vague or known by another name.

Believe it or not, we have just recently received guidance on AI-assisted work in general, and it’s mostly “it’s ok to use AI, but always verify it”, which of course seems completely reasonable, as you should do this with any work that you wouldn’t have done yourself.

Like many others I started feeling it had legs during the past few months. Tools and models reached some level where it suddenly started living up to some of the hype.

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.

It's great. I'd guess 80-90% of my code is produced in Copilot CLI sessions since the beginning of the year. Copilot CLI is worse than Claude Code, but not by a huge amount. This is mostly working in established 100k+ LOC codebases in C# and TypeScript, with a couple greenfield new projects. I have to write more code by hand in the greenfield projects at their formative stage; LLMs do better following conventions in an existing codebase than being consistent in a new one.

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.

I have mostly been using the Claude Sonnet models as they release each new one.

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.

I'm mostly really enjoying it! While it's not my main job, I've always been a tool builder for teams I work on, so if I see a place where a little UI or utility would make people's life easier, I'd usually hack something together in a few hours and evolve it over time if people find it useful. That process is easily 10x faster than before.

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.

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

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)