memjay

Right? This one really hurts to see. I remember just a year ago we all used agents to help us code, but the end result of a session was still a human-made piece that other humans looked at and that we discussed about together.

And because we were talking to colleagues we wanted to make sure that we don’t waste their time. So we kept PR descriptions precise and understandable, we created small reviewable PRs and we wrote review comments that didn’t span half of your page.

Everything felt like it had value to someone.

But I agree with the current pace push it’s nearly impossible to do it any different. And honestly I don’t understand the rush. At least at our company I can’t discern any speed-up yet. Yes, more lines of code are written but features still take very long. It often just moves the work to a different stage in the process.

I am writing too much but I can’t stop thinking about all of this day and night. Sometimes even questioning whether the standards I want to live up to are maybe set too high for this day and age…

Thank you!

The internet is full of people doing the “AI = compiler” comparison and it’s just wrong.

Maybe on a really small scale they can resemble a compiler because the number of possible outcomes is so small that it’s nearly deterministic.

But at any larger scale AI will not be deterministic anymore and at that point it will be relevant what the resulting code looks like. Because it can and will be slightly or very much off from your instruction.

Had this eye-opening moment a few days ago where I enabled our company-wide MCP server and asked for a problem we noticed. The agent looked through slack messages, logs from our devops portal, open telemetry traces and searched code snippets from other services through our RAG code search tool and created nice tables with timings, explanations and suggestion to fix it.

This is an amazing use of LLMs, contrary to offloading your thinking to it during implementation (which does not mean not using to write code but to actually understand the systems you are creating with it, and all their edge cases, inner workings etc.)

I really don’t want to see code generated by Claude without some constraint like rules in a Claude.md file. Even Fable on high is lazy enough to forget a ton of things that a senior engineer would not. For example tracing and handling all unhappy paths, not repeating code, not writing terrible doc strings, etc.

We are using quite a big list of rules and the output is significantly more aligned with what we interpret as “good” code.

Of course you can’t generalize this behavior to everyone. There will most certainly be people who can be disciplined and I try to be one of them.

But I don’t know where to draw the line yet. It’s difficult to decide what parts you are offloading and what parts you keep for your own brain. Because theoretically you can offload nearly everything when you get a well-defined ticket and just give it to an agent.

Maybe it’s also just me who is having a hard time staring at LLM generated texts all day and missing the past brainstorming, pair programming or “just talking about the project” sessions with colleagues and managers.

I fear that we are moving in the direction of silos again with lots of gate keeping as everyone has their own little rubber duck to talk to now.

Systems from today (if not worked on with discipline) will be no more than an agglomeration of features glued together. But as you said, guess our fight to fight will be to be that disciplined person.

Most important one is human communication.

Use AI as much as you want, for research, writing code, reviewing code, etc.

But please, keep communicating on a human level. We are slowly loosing valuable communities when only bots are arguing with each other.

There is no way that solely talking to an agent induces the same depth or amount of thinking than when you are actually writing for yourself. It just takes too much discipline to not offload your thinking.

And the discipline gets attacked even more when all you read is LLM text. For example in code reviews there is no noticeable value in answering LLM generated review comments. I remember taking great care answering human-written reviews comments with much thought to either further build on their suggestions or to forward knowledge about the system when I had to defend a particular change.

Now, some bot will read my carefully written response and forgets about it. There is no value anymore.

No wonder that our pull request comments feel like the dead internet theory right now.

I am absolutely pro AI assisted coding. But communication between humans HAS to stay human. I am currently experiencing the opposite and it’s bad.

I agree that “coding” in the sense of hand-writing code is solved.

But code was made to create architecture, to design systems and also to make actual code (machine code) readable for humans.

In my experience with spec-driven development, the lossy layer of specs on top of code is not the right way to drive development of systems and architecture. The English language is not precise enough to describe those systems.

Of course you can use specs or just prompts to drive the creation of code (I do that for 99% of my code) but the “truth” is still the actual code and not the prompts/specs.

Maybe that’s also just a difference between people (like visual learners vs non-visual etc.) and some have an easier time to grasp every detail of the systems they are working on through code and some through descriptions.

Guess it also depends on the complexity of the software you are developing. For private projects I had more success with spec-driven while at work it would be a terrible choice.

Yes. That’s the problem I noticed with specs too. Agents aren’t really good at finding the right abstraction layer. They tend to write way too detailed specs (e.g. naming variables in specs) and when controlling for less details the output degrades.

But I worry the most about who will be able to define all of those specs (with all of their necessary detail and edge cases etc.) without understanding the systems that live below the specs. Maybe that won’t be a problem anymore if agents will be able to 100% accurately translate specs into code. But for now I imagine this to be really difficult.

Not looking for a new job in this economy though.

Always reminds me of this meme.

Some day we won't even need coders any more. We'll be able to just write the specification and the program will write itself.

Oh wow, you're right! We'll be able to write a comprehensive and precise spec and bam, we won't need programmers any more!

Exactly!

And do you know the industry term for a project specification that is comprehensive and precise enough to generate a program?

Code It's called code.

Yes they are. We just had a workshop where the managers previewed our “software factory”. A big pile of skills, hooks, CLAUDE.md files, an elaborate spec and test system based on many markdown files.

All features should now be created via this workflow. It’s basically a ticket going in, a few rounds of questions back and forth with the LLM, then waiting for an hour until it finishes.

Then having to read/review 2k lines of AI-generated code. It’s terrible.

If I got a dollar for every time I saw an agent skill market on hacker news…

This happens way too often in my experience and I tried a lot of things. If the agent has access to an existing codebase it will always try to stay as close to it as possible. It doesn’t diverge from the initial direction the project/code went into, even if it’s already clear that this direction goes nowhere. Somehow agents aren’t able to detach themselves from existing code to come up with completely new solutions.

Sometimes I feel like it would be best to only give the agent access to clear API boundaries (say public interfaces to certain modules) and let it work out a new system from scratch given the expected inputs and outputs. Then plug this independent solution into the system. Of course it can still overfit these interfaces but it’s less than having access to the entire codebase.

Thinking about it, maybe it’s possible to let one agent extract those interfaces, then use them as grounding for a new session.

One less nice way of achieving the same is to tell the agent once in a while that it should think completely from scratch (from first principles). But this relies heavily on instruction following in the reasoning part, which sometimes works and sometimes fails.

And people complain about AI water usage