I've never been more excited to be a software engineer.
Fight with your org to keep the guardrails. Code coverage, tests, CI. Nothing merged without human review by someone other than yourself. AI commentary on the PR helps speed this along, but there must be accountability.
Now go have fun! If you're typing 100% the code, you are missing out!
Yesterday with Cursor and a roadmap of bullet point features, I wrote ~15,500 lines of code and deleted ~3,890 lines before lunch. I didn't blindly accept any code; I vetted everything. I read and approved every line of code - think of it like reviewing the code as it appears.
It was not perfect - but whose code is? It is my job to get it into shape once it's been generated.
For example. Occasionally it made duplicate components or classes or even files! To that: "hey, looks like there are two FrobWidget classes now, can you take a look?" and it refactored and combined them without disturbing my flow, updating all the call sites too.
When I said "can you make some tests?" it listed out bullet points of names for tests it thought relevant and generated multiple 250+ line test files while I sipped coffee. Because I'd seen the code go in, I could reason about how thorough it was being. At some point I'll ask it to add code coverage.
And this is only guiding one copy of Cursor - imagine a future in which models don't trip up. One engineer can lead a whole fleet.
We aren't paid for how much code we write; we never were. You can use this insane output multiplier to add so much value you make people gasp.
> I vetted everything. I read and approve every line of code
I do not for a second believe that you read and fully understood the impact of 15k lines of code added and 4k lines of code removed in less than four hours ("before lunch")
This is the kind of overconfident BS that is going to run us all into the ground
It helped that I worked from a clear roadmap. After the first feature I was on a roll so I just keep chugging!
It'd be rare to write this much on a single day - after lunch I was exhausted.
This codebase is on a mature stack - in particular, postgres and mature DB migration frameworks like alembic.
I've learned through this process that as long as you get the data modeling basically right, everything else can be fixed as you proceed through testing your own work, from checking each little UI feature does what the code claims, all the way to end-to-end.
Imagine you can do massive refactors just by asking the model a few questions, what does that unlock?
> I've learned through this process that as long as you get the data modeling basically right, everything else can be fixed up as you proceed through
"basically right" is not the same as "actually right"
> Imagine you can do massive refactors just by asking the model a few questions, what does that unlock?
It unlocks the ability to take an established codebase that is presumably well understood by the people who wrote it and turn it instantly into a completely new codebase that no one understands and is basically impossible to work on
You sound like a junior developer who still thinks that the job is writing lines of code
First let me tip my hat and thank you for engaging on this. I think though that we're talking past each other which isn't my goal. So I'll try to explain a little clearer.
The concerns you raise are valid. The process in my example is more rushed than I'd go through in a team context. This is a relatively immature project I'm exploring solo, so the appropriate level of "process overhead" is different than in a team context. I didn't take the time to separate that from what I'd do in a team.
In a team, there'd be upfront discussion to align on what's in the "roadmap" (ie. we'd write a spec), there'd be discussion as the work proceeds if tech-debt emerges and refactors are needed, there'd be CI, tests, coverage, and code review. A good team would own the code forever, so they'd be happy with any refactoring.
When I said massive refactors I meant within the context of one PR. It's insanely freeing to be able to draw with crayons all over your codebase, see what works, and then either `git reset --hard` or refactor it into shape.
If a refactor of existing code is needed, that's its own PR.
In summary, almost nothing changes at the level of team process. Keep all those guardrails - but use these tools to 1000x the amount of typing & exploration you can do!
Fight with your org to keep the guardrails. Code coverage, tests, CI. Nothing merged without human review by someone other than yourself. AI commentary on the PR helps speed this along, but there must be accountability.
Now go have fun! If you're typing 100% the code, you are missing out!
Yesterday with Cursor and a roadmap of bullet point features, I wrote ~15,500 lines of code and deleted ~3,890 lines before lunch. I didn't blindly accept any code; I vetted everything. I read and approved every line of code - think of it like reviewing the code as it appears.
It was not perfect - but whose code is? It is my job to get it into shape once it's been generated.
For example. Occasionally it made duplicate components or classes or even files! To that: "hey, looks like there are two FrobWidget classes now, can you take a look?" and it refactored and combined them without disturbing my flow, updating all the call sites too.
When I said "can you make some tests?" it listed out bullet points of names for tests it thought relevant and generated multiple 250+ line test files while I sipped coffee. Because I'd seen the code go in, I could reason about how thorough it was being. At some point I'll ask it to add code coverage.
And this is only guiding one copy of Cursor - imagine a future in which models don't trip up. One engineer can lead a whole fleet.
We aren't paid for how much code we write; we never were. You can use this insane output multiplier to add so much value you make people gasp.