- Work on small projects (< 500k lines of code).

- Work for business people who want fast results. Agentic coding gets you to something presentable much faster at the cost of code quality. I have never seen a customer or business person care about that.

- Have clearly defined API boundaries. Examples: If the back end is solid you can just vibe code the first version of a front end according to some mockup. Define a data pipeline with steps and clear contracts of what data gets passed around and what each step does. If the LLM messes up one step, rip it out and rewrite it.

- Have clearly set up workflows for tasks. Start with a "ask me everything" phase, then comes a plan phase, a review phase, an implementation phase, another review phase and then the integration phase. Multiple agents going over the same problem catch a surprising amount of dumb stuff that would otherwise slip through.

- Set up excellent testing. Build your whole architecture around being easy to test.

- Have skills for common problems. For one of my projects I had to set up a skill on how to query the ORM, because Claude was consistently doing database operations in a for loop, where it could use batch operations.

The code in the end is better than a lot of the code I've seen humans write.

I don't think this works for everybody and every project. If you have a culture that values code quality and readability, if you work on large existing projects, if you have to nail the architecture of some non-trivial piece of software etc. you are going to have a bad time.

On the other hand you can probably build the MVP of your AI-supported CRUD app 10-20x faster.

I think a lot of the discussions around development tools and techniques just stem from two facts:

1. Developers work on widely different projects with different management and constraints.

2. Tools, libraries, frameworks and code style have to match your mental model, otherwise you going to dislike them.

I am mostly working on small to medium sized Next.js and Kotlin projects and Claude works really well, while Codex often misunderstood my instructions, while I was testing it.

This is a book that helped me getting started: https://www.amazon.com/Roaring-Silence-Discovering-Mind-Dzog...

The diagnosis I got from my therapist is PTSD from my chikdhood due to the strong connection between stress and body.

The only thing I found that alleviates my symptoms short term is lots of Buddhist meditation (1-2 hours per day).

I wish you all the best and thank you so much for sharing.

So I would learn things that are either fun for you to learn or things that you can directly apply.

For AI this means you probably should learn about it if you are really interested and enjoy going through build-your-own-NN tutorials or if you have good chances of switching to a role where you can use your new skills.

Edit: Basically investing anything (also time) is risky. So invest in things that directly pay off or bring you joy regardless of the outcome.

Why does creating a backtrace need such a large amount of memory? Is there a memory leak involved as well?

In good Java code you would return either void to indicate side effects or the newly saved user. Exception handling should be done outside the function, because depending on the context you might retry etc.

The main idea is to check if people who say they are very experienced understand conventions and have experience with common Java libraries.

Because many people were interested in some actual code, here is an example that we used for Java:

---

public class UserDao {

    private Provider sessionProvider;

    public UserDao() {
        this.sessionProvider = new DbSessionProvider();
    }

    public boolean saveUser(User user, ApiConfig config) {
        try {
            Session session = sessionProvider.get();
            session.save(user);
            System.out.println("User saved!");
            return true;
        } catch (DbException e) {
            EmailUtil.sendEmail(config.getTechnicalSupportEmail(), e);
            return false;
        }
    }

---

"Solution": We always ask the candidate "What would you change about this code?" or something similar. We expect the candidate to come up with some selection of: - Database sessions should come an injected provider. - Configuration should probably be injected as well and not passed as a method parameter. - Booleans are not canonical Java as return value. - Don't write to stdout but to a logger. - Exception handling should probably happen outside the DAO. - Don't use static methods for sending Emails without good reason. Non-static methods are easier to test.

Finding these things is as important as being able to talk about them and give background on advantages / disadvantages of doing things different ways. With good candidates one can talk easily half an hour just about this example and adjacent topics (e.g. error handling).

---

Edit: Formatting

Edit 2: added "Solution"

Btw great product! Just really curious about a personal pain point of mine!

  Location: Vienna, Austria
  Remote: yes
  Willing to relocate: no
  Technologies: Angular, Java, PyTorch, Tensorflow, Python, PostgreSQL, SQL, Presto, Hive, AWS, Typescript, Hibernate and many more
  Résumé/CV: https://www.dropbox.com/scl/fi/4rni8wxfjzwa7qv4usdw6/CV_Duer_20240401.pdf?rlkey=049japrdopw5y33wulkb9b86h&dl=0
  Email: mail.duer[at]gmail.com

I spent the last 5 years as the founding member and CTO of a startup, which still thrives under the leadership of my two co-founders. There I architected, designed and developed a procurement software for custom made packaging that convinced customers with industry revolutionizing features and excellent UX using Angular, Java and PostgreSQL. I also applied state-of-the-art optimization and machine learning algorithms to industry specific tasks. One example is a packaging size optimization service that I created, which saves Germany's leading e-commerce websites (e.g. Flaconi) 10 - 15% of packaging and shipping costs every day.

Before that I worked as a data engineer at a global mobile advertisement company. I worked on extremely high traffic systems with hundreds of servers, where the limiting factor was the number of requests, which required us to switch to an asynchronous architecture by migrating our application to Vert.x, which reduced the number of required computing resources by over 60%. I also delivered on a data pipeline redesign, where we reduced data storage requirements by 80% through efficient sampling, which saved tens of thousand of dollars every month.

If you are interested in working together feel free to reach out.

For example a static page with a booking process with various entry points on the website, which slightly change the booking logic. Also you can book as a new user, as a logged in user, for somebody else etc. Also the logic is changing at regular intervals, because the business owner is trying different things out.

Using Angular with reactive forms makes this easier to develop, maintain and hand off to other Angular devs.

While it makes writing the static parts of the website more complicated, it makes developing the booking process easier. And overly complicated business processes are what is mentally challenging for me. This is where I want all the help I can get. Writing static pages is something I can do in any framework even when I am tired. Making this part easier or reducing boilerplate is nice but doesn't make me much happier. Being able to build ridiculously complicated forms without my head exploding does :) Of course if you work on projects with relatively straight forward requirements there is 0 advantage in using Angular or React for you. It always depends on the type of work you do.

Many developers also dislike using many different frameworks, because that would require more learning. If you have to choose one technology it's better to use one where you can do everything. Not one where you can do 95% really fast, but 5% not at all.

I personally always use "complex" frameworks like Angular or React because sooner or later feature requests come in, where those frameworks pay off. On average it saves time for me to always use those frameworks. That might be different for you depending on the work you do.