The new age of software development: what changed and what did not
A build week for a small business tool looks nothing like it did a few years ago. The typing is gone. Almost everything around the typing is still there.
AI tools now write most of the code, so the slowest part of building software, turning a decision into working lines, is nearly free. What did not change: someone still has to decide what the software should do, design the data, test on the real system, own the accounts and maintain it when the world moves. The job shifted from writing code to making decisions and checking results.
What a build week looked like a few years ago
An owner described a scheduling problem. A developer wrote a plan, then spent most of the week typing: forms, database tables, the logic that stops two drivers from booking the same van. Reviews happened at the end. Bugs showed up after launch because the only testing was on the developer's laptop. A change request meant another week.
What it looks like now
The same owner describes the same problem. We write the description down carefully, in business language. An AI coding tool turns that into working code within the hour. We put it on a live preview address, open it on a phone, and try to break it. We send the owner a link the same day. Most of the week goes to the conversation, the data design and the checking, not the typing.
That is the headline change. The part of the job that was slow and expensive, turning a decision into working lines of code, is now fast and cheap. Everything that was never about typing is exactly where it was.
One practical difference is worth naming. Every project now carries a short rules file that tells the coding tool how that project is built, tested and deployed: which branch is live, where the secrets are, what never to run locally. The tool reads it before it starts, the same way a new employee would read a handbook. Writing that file well is a new skill, and it replaces a lot of what used to be hallway knowledge.
What did not change
- Requirements. Software still does what it was told, not what was meant. An AI tool writes a perfect version of a vague request. The skill of asking "what happens when a shift is cancelled an hour before it starts" is worth more now, not less, because the answer becomes code so quickly.
- Data. Deciding what gets stored, in what shape, and who may see it is still the decision that everything else depends on. A tool draws screens happily; it does not know that a lead and a customer are the same person at two points in time.
- Testing on the real thing. Code that works on a laptop is a rumor. We verify every change on a live preview, on real devices, with real accounts, before it is merged. The AI did not remove that step; it made it the main step.
- Ownership. The code lives in your repository, the database in your account, the hosting on your card. No tool changes who holds the keys.
- Maintenance. Suppliers change their terms, a phone update breaks a camera permission, a map service renames a field. Someone has to notice and fix it. Faster writing means faster fixing, but it still needs a person watching.
What got cheaper, specifically
- The first draft. A working prototype now costs an afternoon, so we show rather than describe.
- The second system. Once a CRM runs for one trade, the version for another trade is mostly a conversation about fields and scoring.
- Small internal tools. A driver handbook with search, a vehicle inspection app, a shift board. These used to lose to a spreadsheet on cost. They do not anymore.
- Changes. "Can the report also show no shows by location" is a same day request, not a change order.
What got harder
Judgment got harder, because there is more to judge. When code is cheap, the temptation is to build everything, and a business ends up with nine half used tools. The discipline now is choosing what not to build, and keeping each system small enough that one person can hold it in their head. It also got easier to ship something that looks finished and is not. A polished screen over a broken data layer is the signature failure of this period, and the cure is boring: test on the live system, read the parts that matter, and keep a human on the hook for the result.
We build with these tools every day, for a landscaper, a builder, a retirement advisor and a transit company, and the shape of our week is the shape described here: short on typing, long on decisions and checking.
Questions people ask
If AI writes the code, what is a developer actually doing now?
Deciding what to build, designing how the data is stored and protected, checking the result on the live system, and owning the thing afterward. The typing was never the valuable part; it was just the slow part. Removing it leaves the judgment, which is where the value always was.
Does AI written code need more testing or less?
More, in a sense, because it arrives faster and looks more finished than it is. We treat every change the same way regardless of who wrote it: deploy it to a live preview, use it on a real phone with real accounts, then merge. The speed of writing is only useful if checking keeps up.
Will software built this way be maintainable in a few years?
Yes, if it was kept small, documented in the repository and stored in your own accounts. The tools that wrote it will change, but plain code in a standard framework can be read and edited by whoever comes next. What makes software unmaintainable is sprawl and secrecy, not the tool that typed it.
Want this done for your business?
Two minute intake. A real person reads every one and replies within a business day.
Keep reading
Vibe coding: what it is, what it is not, and what it means for your business
Vibe coding explained for owners: describing software in plain English and letting AI write it.
New softwareWe cloned a CRM for a new industry in a day. Here is how
How a CRM built for a home builder became a landscaping CRM and an advisor CRM in a day: what stayed, what changed, and why a proven core beats a blank page.
New softwareClaude Code, Cursor and the tools we actually build with
A plain tour of the AI coding tools a small studio builds with: terminal agents, editor assistants and browser builders, what each is for, and why we mix them.