recommended reading. i like the term "coherence" over "taste". historically, simplified, a human would approach a software writing human, asking them to build a thing. that's an iterative process, until software writing human truely understands what the other human needs and wants. which is also why we moved away from waterfall. you often can't know what you want before you've build a first shitty solution you can feel out. and your wants might change. in this scenario, the outcome is what matters, not the program structure itself, unless that makes the outcome worse/impossible (bugs, perf, ease of adding features). the software writing human's skill is not so much programming itself, but understanding the other humans wants, pulling out domain knowledge from the other human, asking questions, and ultimately translating the other human's wants into programs, while ensuring the program structure is fit to be modified for future needs. now, can you replace the software writing human with an agent? for simple one-off stuff, yes. if the human with a want is technically minded that extends to more complex programs. most humans suuuuuck at this iterative colab with agents tho, as they are bad at structuring and communicating their wants. and agents currently still suck at the software writing human skill of colaborating with another human to understand their wants and translate them to a program. my gut tells me that this is because the training data and RL for coding agent tasks is largely composed of trajectories where a software writing human and an agent colaborate. that missed the other half of the problem: the human with a want and software writing human interaction. and until we can encode that agents for writing programs will likely only be effective in the hands of software writing humans, or very technically minded humans. another thing agents currently suck ar is translating software writing human shallow instructions into architecture that's not a house of cards. i think this too is a consequence of the lack of training data/RL-able trajectories that encode the process a team of software writing humans go through when building a thing. we do have digitized artifacts (design docs, commits/PRs, issue trackers) that capture some but not all of that. i think this will improve, as we all are now doing design sessions with our agents, so labs could in theory train on that. however, even if this data were available and becomes part of training, the pretraining data still has tons of shit code from around the internet in it, ehich posttraining would have to combat. welcome to my morning word salad.