I like this as reference. I haven't seen a design doc properly used for implementation in a long time. More often design docs are there to facilitate collaboration - here's the basis of conversation topics that are interesting; these are the things that matter most and here's the foundation for discussion so we can get aligned. It's all too easy for a team to ignore or TL;DR a design doc which goes on and on about things that don't matter, and that can become a problem for an architect trying to implementation which winds up going off the rails because no one actually read the doc.
"Do the work assigned to them" has multiple levels of abstraction. You could say it's the task level which would be entry level. You could say it's the project level which would be mid level. You could say it's the a service or domain which would be senior. Staff should be tackling org wide and cross-team issues. The amount of scope and clarity needed for a "problem" changes and gets larger in expectation and more terse in explanation the further you go.
Do people have fun building vim macros? Vim macros are awesome because they don't involve reading manuals, memorizing obtuse key commands which you never use on a regular basis, or understanding weird configuration lines - you just use the editor the way you normally would except you're hitting record. Vim's power is that I can be editing, notice I don't have something, make it in 2 minutes, and then get back to more normal work. At least try to understand the thing first before criticizing it?
Running tests is a good example: do you want to run them from your IDE or do you want to run tests in the terminal?
The IDE folks praise the simplicity of having one tool which can run tests quickly without requiring added context and with having other IDE features able to load test context quickly.
The terminal folks praise the modularity, at-will configuration, and transparency. You do things the way the rest of the community does which makes it easier to get support and debug when things go wrong. Tests become a small tool you can reuse in other contexts (git bisect, watch commands, CI)
“memorizing obtuse key commands which you never use on a regular basis” is exactly why I prefer Emacs over vi(m). The default configuration on Emacs works like most other contexts—I can just use the arrow keys to position a cursor and type.
And then, at least on the Mac, some of the basic commands in Emacs carry over not just to the terminal, but to things like text input windows in Safari and other Mac-assed apps so I can almost always use ctrl-a to go the beginning of a line, ctrl-e to go to the end, ctrl-k to delete to the end of the line and sometimes also I get esc-del to delete the previous line although that works in terminal, but not a Safari input window (and escape gets captured in IntelliJ’s terminal which kind of stinks).
I do feel that common config across a team is always a good thing. I’ve been the only IntelliJ guy on an Eclipse team and the only Eclipse guy on an IntelliJ team and both cases were worse than conforming to the convention.
Sometimes I feel like the only sane person in the room for not wanting to have to usher the LLM through phase by phase. Every time I need to choose the next skill or cat the next error is just a waste of my time that could be spent doing things that actually need my attention like making business tradeoffs.
I’ve found LLMs very good at two things: 1. Recommending paths forward, 2. Following established architecture. Your job is to be able to treat the LLM and code as sheep
Why would you do anything else? It’s still faster than me doing it as long as I’m parallelizing. I can regularly get up to 5-6 things running in parallel at the moment with no downtime. I suspect by EOY I’ll figure out how to run more
reply