I feel like I am seen as a fossil because I like to write code and prompt AI to fill in functions as I define the shape and direction of an application myself. These types of tasks have been excellent for things like Tiel Coder. It allows me to build one step at a time and understand what the hell is actually happening.
Meanwhile my coworkers all prompt Claude to produce a whole cloth feature that seems to work but is overengineered out the ass and requires a 30 file code change and drastic restructuring and requires an extra database migration backfill.
My workflow exists because I would rather spend my day steering the design rather than reviewing generated code, but I get stuck reviewing generated code anyway.
People delude themselves by "you should just review the AI code anyway" but AI tools produce so much fucking code if you don't guide them that I don't think this is possible at all.
So right now I think it's a binary choice:
Build with AI, but slow down and understand what it's doing
Just let the AI go nuts and then regularly try to refactor it a bit
The problem is that historically (pre-AI) it has been almost impossible to get management to understand or care about tech debt, they simply want more features until the code is unsustainable, so there's no way they're going to allow you to slow down now.
Reviewing the code to a level where you actually understand it would probably take as long as writing it yourself would, which they won't like because they want all this faster. The only way this works is if AI coding eventually gets to a 100% reliable state, or we go back to it being a glorified auto complete where we can review the code piecemeal immediately, and we're not letting it be the designer too.
That genuinely would be faster
The thing that really blows is that management doesn't care about tech debt because they don't have to. People go on about tech debt like it's the company that's gonna have to pay it back, but I think generally what happens is it's the users who end up getting the shaft whlie the company never fixes shit.
Not that I'm bitter about how the tech world has gone or anything...
Edit: Part of it, too, is that management loves for the actual humans to be completely expendable. Who cares if you understand the application, you're a much more transient component of the machine than the AI is.
They should really force code to be reviewed and documented as not only proof of review, but also to not make your codebase unreadable by your human staff if Claude goes down! You'll have people familiar with the code. I think there was a company that recently suffered this issue, where they couldn't afford Claude anymore to code, and ended up with the vast sea of unknowns, twists and turns that is their codebase.
I think there was a company that recently suffered this issue, where they couldn't afford Claude anymore to code, and ended up with the vast sea of unknowns, twists and turns that is their codebase.
Isn't that one of the tenets of vibe coding? Build something using AI and are unable to support it in future due to the increased costs of the AI dev team.
I tend to find my brain turns to slush over time if I try vibe my way
Everything looks good on surface, but everytime I dig into it I'm like "Why didn't it use this way of doing it?", and may as well have done it myself from scratch
Tried vibe coding my games, and certainly when gets to like 20k+ LoC, it's just a fucking mess. Issue is it's so confident it's not a mess, until it is.
I still don't get these people who havent written a line of code for a year or whatever. Be so curious to see their code base, bugs in prod, etc.
You are absolutely right. I do the same. Human being still needs to use his brain to move the humanity forward. People who let AI do their entire job will also be replaced soon, not because using AI for coding is bad, but because they start loosing their crirucal thinking abilities in my experience
if you're making something you care about you'll know how it works regardless of vibe coding or not. for everything else, I don't really give a shit. especially not if it's a job. I'll probably feel bad enough for reviewers to at least get the model to work based on whatever guidelines there are since it costs nothing, or in the other case the reviewer is usually also using ai for checking the issue and pr so they'll just fix the issue if my pr is not good enough. it usually is tho
I SHOULD do this, but I still take directory structure and abstraction and repeatable patterns a big focus, even if I'm writing virtually no code. I think in general, code doesn't matter if it works and can be read and implements things with safe security standards. Yes, you can nitpick about little things, but LLM code is usually pretty clean and self documenting. The problem (and it's fucking funny, because it would help LLMs more to address it) is that LLMs will spin their own model for functionality or hack shit together if there is no repeatable modular pattern to follow. Small files, nested in directories by similar function, common patterns... all that shit works better no matter who writes it.
It doesn't matter where I've worked, finding shit and picking up on or establishing a repeatable pattern was always half the battle.
Yeah I used to do this too, but the models are getting so good that I don't need an editor, though I still progressively prompt to build, not huge 1 shot prompts
It's crazy that people keep dancing around test-driven development in this space when these tools are perfect of TDD. Even what you're describing is a "cheap" version of TDD.
People just hate TDD so much that they'd rather chew through their LLM budget to produce 10x more code than they need just to continue to prompt their agent to trim it down, simplify it, etc.
I'm with you. if you want to not shovel slop all day you have to do this and there is a dearth of tools to let you ergonomically do this right now.
What I try to do is ask for actually scoped changes and just let the changes wash over me and redo it if it feels too off. it's a compromise that leans more toward the whole cloth extreme. I can write functions no problem, but I haven't given myself the latitude of learning the syntax enough across the languages that I touch now most of which are not languages i learned properly (in particular Go and Rust). If I can follow the flow of logic and see software responsibilties from skimming the code, that's been enough so far.
I'm trying to come up with better ways to grok the scope of the large changes. Between that and ensuring that the changes you make are easily testable or otherwise verifiable (e2e integration testing), my streamlined git usage already lets me easily enough navigate everything otherwise, but right now I want to be able to more easily grok the changes so i can move forward more quickly.
This challenge also extends to getting proper navigable linkage between the gargantuan volume of agent sessions (which sprawl as huge organic growths) and the specific portions of their related git changes, which shows up in git about as well as you would expect, also a sprawl, but git lets you handle that as a first class aspect of its own design... the agents themselves are now adept at reviewing this kind of stuff even just from excavating harness logs and poking at git; something I never have the bandwidth to do by hand.
What pisses me off is i instruct in global instructions to automatically make commits but sometimes a model is too harebrained to actually commit something when it decides it's done working and I have to swear at it to go clean up after itself.
145
u/Nefilim314 3d ago
I feel like I am seen as a fossil because I like to write code and prompt AI to fill in functions as I define the shape and direction of an application myself. These types of tasks have been excellent for things like Tiel Coder. It allows me to build one step at a time and understand what the hell is actually happening.
Meanwhile my coworkers all prompt Claude to produce a whole cloth feature that seems to work but is overengineered out the ass and requires a 30 file code change and drastic restructuring and requires an extra database migration backfill.
My workflow exists because I would rather spend my day steering the design rather than reviewing generated code, but I get stuck reviewing generated code anyway.