As someone already pointed out, everyone is trying to navigate this at the same time, but I think core fundamentals still apply. Everything that makes it easier for a human to contribute to a codebase also applies to agents:

1. Rely more on automation (linters, rules, CI checks, tests, etc). Writing custom credo rules is especially powerful to enforce conventions.
2. Writing down non-obvious conventions and patterns (or preferences), which would also make it easier for an agent to pick those up (something has been historically difficult for teams that rely more on “taste” and “gut feeling”).
3. Apply the progressive disclosure pattern when organizing code so it’s easier to discover and ensure that things are properly documented (and Elixir makes this really easy, especially if you have documentation with good examples)
4. Doubling down on accountability. You are still responsible for the code you generate, not the LLM (if something breaks, you should be able to fix it).

In other words, give people (or agents) the best tools for them to do their best work. But all of the above also speaks to creating a better harness for the LLM to generate code for you, which goes from properly architecting your solution to everything that comes to maintain that (fighting entropy basically).

People often describe the human work now as being the “quality gate” for LLMs; however, I think the correct mindset is being the “quality road”, meaning you don’t defer making good decisions to the end of the process. So in practice, nothing really changed, except that you iterate much faster than before.

Also, it’s useful to remember that the 10x multiplier in the right hands can also be used to refactor and tidy things, so you have to keep your team accountable as before. All that being said, it’s also important to mention that discovery happens so much faster now that sometimes it might be better to optimize for that instead.

PS.: The only point from my list that really concerns me is the 4th one. Now that some companies are pushing for PMs and other non-technical functions to produce code, it creates an inbalance on the trust dynamic because they can’t verify it, which hurts accountability on many levels.

I think I’ve identified the core reason I instinctively dislike LLMs.

I strongly value competence. This applies institutionally as well as societally, not just individually. In a competent society, things just work.

You can take a hot shower because there is clean water and flammable gas piped into your home, a device on premise that burns the gas in a safe, controlled way to heat the water, and a sewerage system to carry the dirty water away to be disposed of cleanly. Not to mention the electricity being used to light your home and power the water heater, and the technology that went into building the home in the first place.

Almost none of this you could achieve alone. But you enjoy the benefits of a shared competence. There is an institutional knowledge at work that ensures you can take the benefits of our technological inventions for granted as part of your daily life.

LLMs replace this hard-earned institutional competence with statistical guesses - a literally incompetent imitation.

Of course, nobody can use an LLM to build a hot shower. But what if the people at the water company stopped knowing authoritatively how to purify water, and instead relied on an LLM? What if they stopped caring about fluid mechanics to get the water safely pumped to your house? What if the producers of the water heater stopped caring about controlled combustion, the sewage company about not dumping sewage into streets and rivers, the electricity company about electrical fundamentals or the builders of your home about solid architectural principles and following through with proven construction practices?

These are the institutional competencies we rely on. LLMs incite individuals to turn not to the institutional knowledge that we have collectively built, but instead to settle for a statistical approximation, eroding the forces that built the shoulders we stand on.

(also blogged a few hours ago)

I only just recently hit the acceptance stage for agentic coding, so I don’t have a lot of experience (and I’m not a manager). One thing I have not been letting it do is commit for me. This probably ruins some workflows where one person has a bunch of agents working on several features at once, though I haven’t reached the level of acceptance where I think that is in any way even a remotely good idea for production apps In any event, manually committing forces me to work in a more careful way, reviewing each step of the output along the way (the commit message itself can still be generated, of course).