While I imagine “make an app that does X” won’t be as useful as “if … else” there is a middle ground where you’re relinquishing much of the control you currently are trying to retain.
For the AI to avoid this, I'd imagine it would need to be directed not to assume anything, and instead ask for clarification on each and every thing, until there is no more ambiguity about what is required. This would be a very long and tedious back and forth, where someone will want to delegate the task to someone else, and at that point, the person might as well write their own logic in certain areas. I've found myself effectively giving sudocode to the LLM to try to properly explain the logic that is needed.
I would argue that as an industry we love high level programming languages, because they allow you to understand what you are writing, much easier than looking at assembly code. Excellent for the vast majority of needs.
But then people go right on and build complicated frameworks and libraries with those languages, and very quickly the complexity (albeit presented much better for reading) comes back into a project.
There will be niches in research, high performance computing & graphics, security, etc. But we’re in the last generation or two that’s going to hand write their own CRUD apps. That’s the livelihood of a lot of software developers around the world.
To me it's similar to saying that there's no need for lawmakers after we get the basics covered. Clearly it's absurd, because humans will always want to expand on (or subtract from) what's already there.
Right now I'm wring a web app that basically manages data in a db, but guess the kinds of things I have to deal with. Here a a few (there are many much more), in no particular order:
- Caching and load balancing infrastructure.
- Crafting an ORM that handles caching, transactions, and, well, CRUD, but in a consistent, well-typed, and IO-provider-agnostic manner (IO providers could be: DBs like Postgres, S3-compatible object stores, Redis, Sqlite, Localstorage, Filesystems, etc. Yes, I need all those).
- Concurrent user access in manner that is performant and avoids conflicts.
- Db performance for huge datasets (so consideration of indexes, execution plans, performant queries, performant app architecture, etc, etc)
- Defining fluent types for defining the abstract API methods that form the core of the system
- Defining types to provide strong typing for routes that fulfill each abstract API method.
- Defining types to provide strongly-typed client wrappers for each abstract API method
- How to choose the best option for application- and API security (Cookies?, JWT?, API keys? Oauth?)
- Choosing the best UI framework for the requirements of the app. I actually had to write a custom react-like library for this.
- Media storage strategy (what variants of each media to generate on the server, how to generate good storage keys, etc.
- Writing tooling scripts that are sophisticated enough to help me type-check, build, text, and deploy the app just in the way I want
- Figuring out effective UI designs for CRUD pages, with sorting, filtering, paging, etc built in . This is far from simple. For just one example, naive paging is not performant, I need to use keyset pagination.
- Doing all the above with robust, maintainable, and performant code
- Writing effective specs and docs for all my decisions and design for the the above
- And many many more! I've been working on this "CRUD" app for years as a greenfield project that will be the flagship product of my startup.
Software is codified rules and complexity, which is entirely aribtrary, and builds off of itself in an infinite number of ways. That makes it much more difficult to turn into factory output cabinetry.
I think more people should read "No Silver Bullet" because I hear this argument a lot and I'm not sure it holds. There _are_ niches in software that are artisanal craft, that have been majorly replaced (like custom website designers and stock WordPress templates), but the vast majority of the industry relies on cases where turning software into templates isn't possible, or isn't as efficient, or conflicts with business logic.