Okay, I think I should celebrate this as a milestone. <tada>
I have officially put an enterprise-level application into production.
Like, actually production. It’s live. It has real users—or, theoretically, it can have real users. It has analytics. Monitoring. Authentication. Infrastructure. Logs. All that jazz.
For the first few days, of course, it was very quiet. I spent an embarrassing amount of time watching my traffic metrics, waiting for something exciting to happen.
Users online: 1
Oh! It was me. Lol
But still. Penny Palette is out there. On the actual internet. Doing things. And one of the strangest things about building it has been realizing just how much easier it has become to build something at this level.
Apparently I have a development team now
I’ve been around software for a long time, but these days I’m very much a generalist. I know how I want things built and how I want the pieces to fit together. What I’m not is completely up to date on every framework, library, tool, cloud service, syntax change, and new way we’re apparently doing things this Tuesday.
Vibe coding isn’t actually that different from how I used to work. It just compressed a lot of the process. Whenever I needed to build something, I usually knew the logic I wanted. The next step was figuring out how this particular framework wanted me to do it. So I’d end up on Baeldung, reading documentation and tutorials, opening several Stack Overflow tabs, and doing a ridiculous number of Google searches until I figured out the syntax and implementation.
Now that whole process feels a little different. Instead of bouncing between ten tabs and piecing the answers together myself, I can have one conversation with an agent. And this is where AI has been kind of amazing for me.
I don’t necessarily need someone to teach me software engineering—although, lifetime learner that I am, I will absolutely listen. I need someone sitting next to me who knows what everything is called now. That distinction turns out to be pretty important.
I used to buy a giant programming book, read 700 pages, build something stupid involving Employee and Department, take a certification exam, and eventually feel qualified to touch the technology. Now I can say, essentially:
Here’s what I’m trying to build. Here’s how I want it architected. Here are the patterns I want you to follow. Don’t make a mess.
Enter. And off it goes.
To be fair, that Java foundation absolutely helps. A lot. The syntax changes. The frameworks change. The fundamentals don’t disappear quite as quickly.
Refactoring might be my favorite part
This may actually be the coolest thing. There are so many refactoring tasks in software development that aren’t particularly difficult. They’re just tedious.
Move this into its own component. Separate these responsibilities. Rename this everywhere. Reorganize this package. Extract this service. Clean up these imports. Apply this pattern consistently across 37 files without mysteriously destroying something on file 26.
These are exactly the kinds of things I used to look at and think:
Yes, this absolutely needs to be done.
I absolutely do not want to do it.
Now I can hand that work to an agent. Even better, I can tell it how I like a codebase organized. I can give it the architecture I want, the conventions I care about, the best practices I’ve accumulated over the years, and all my precious little “-ilities.” Maintainability. Scalability. Testability. Reliability. Observability. All the ities.
Give it a good enough instruction, hit Enter, and watch it work. It’s dangerously close to waving a wand and saying:
Make my code pretty.
And then it does.
It writes the documentation too?!
This part still amuses me. After doing all of that, I can ask it to document the architecture. And it does. Not just a sad README that says npm install.
Actual architecture documentation. Components. Responsibilities. Data flows. Decisions. Mermaid diagrams.
Do you know how hard it is to keep architecture diagrams updated? Now the machine that helped build the architecture can draw the diagram. What a time to be alive.
I still don’t just let it loose
This is probably the important part.
I watch it.
One thing I really like is being able to see what it’s thinking about doing before it does it. Sometimes I’ll watch the direction it’s taking and think:
Nope.
Stop.
Because AI can be extremely capable and still confidently head toward a solution I don’t want.
None of this means I just accept whatever the agent gives me and ship it. I still review the code, test it, make the architecture decisions, and decide what actually makes it into production. I probably said “Undo” multiple times. The difference is that I don’t necessarily have to type every line myself anymore.
Sometimes it’s technically reasonable. Sometimes it’s solving a slightly different problem. Sometimes it wants to introduce something that I specifically don’t want in my architecture. And sometimes I just know the codebase better. That’s where the human part still matters. I’m doing less of the mechanical work, but I’m still making the decisions. I haven’t outsourced judgment.
I’ve outsourced a shocking amount of typing.
My engineering org chart is getting ridiculous
At this point, I basically feel like I have a development team.
Luna is my junior developer – Fast. Eager. Great for getting things moving.
Terra is my mid-level developer – Give Terra something with a little more meat on it.
Sol is my senior developer – This is where I go when I want someone to think through the problem with me instead of immediately attacking the keyboard.
Astra is Staff – Astra gets the stuff where I want someone looking across the system and asking whether we’re doing something stupid architecturally.
And then there’s Claude, the mega-developer I had to fire for being too expensive.
Sorry, Claude. Budget cuts.
Gem is currently filling in as the offshore temp replacement.
It’s a very lean organization. Benefits are terrible.
Anyway, I shipped it
That’s really the milestone.
I had an idea.
I designed it. Architected it. Built it. Refactored it approximately seventeen thousand times. Put infrastructure around it. Deployed it. Added monitoring and analytics.
And now it’s running in production! Maybe the analytics dashboard occasionally still says:
Users online: 1
And maybe that user is still me.
But you know what?
Production is production.
I’ll take it.
