Just-in-Time Software
Just like cloud killed the server rack, AI is killing fixed tools. I built a full E2E test system from scratch—faster, cheaper, tailored—using nothing but schema, rules, and AI prompts. Why buy tools when you can generate them just-in-time?
Why the Future of Consulting Won’t Be Tools — It’ll Be Patterns
A shift is underway in enterprise tech, and it’s bigger than just “AI is coming for code.” We’re approaching a new inflection point — one that mirrors the rise of cloud infrastructure, but hits the consulting layer instead of the hardware.
Here’s the thesis:
Just like infrastructure moved to the cloud, software frameworks and internal tools will move to AI-generated execution — built just-in-time, from reusable patterns, by intelligent agents.
Not long ago, provisioning infrastructure was slow, expensive, and tied to physical assets. Then we got infrastructure-as-code. Now, few architects think in terms of servers — they think in terms of modules, templates, and autoscaling groups.
We’re about to see the same transformation with software delivery frameworks.
🧠 From Owning Tools to Describing Systems
I recently built a full end-to-end testing system using nothing but:
- Domain knowledge
- A clear architecture
- And AI development assistants (in my case, Kilo and custom prompt templates)
In under an hour, I had:
- A robust Page Object Model across every admin view
- Deterministic test environments, seeded via fixtures
- CI-ready scripts with tiered run modes (smoke, full, responsive)
- Role-based test logic mapped to my app’s permissions model
This wasn’t about wiring up Selenium or configuring TestRail.
It was producing the equivalent of those tools, purpose-fit to my system — without buying a license, waiting for a vendor update, or wrestling with generic workflows.
Now imagine that happening not just for testing, but for:
- Auth logic
- Internal dashboards
- Data pipelines
- Onboarding flows
- Notification systems
- Even CRM workflows
🧩 What This Means for Enterprises
This isn’t a side project anecdote. It’s a preview of where our tooling model is headed.
Most enterprise IT portfolios are still dominated by:
- Off-the-shelf QA platforms (Tricentis, Perfecto, etc.)
- Heavily customized internal frameworks that take months to onboard
- Toolchains that are loosely integrated and over-licensed
But as AI-assisted development becomes viable at scale, we’ll stop relying on fixed tools and start relying on modular blueprints + intelligent generators.
Think:
- Prompt-driven test harnesses instead of centralized QA platforms
- Schema-to-UI generators instead of low-code vendors
- Rule-based scaffolding instead of full-stack teams for CRUD apps
🛠️ Tools Become Patterns
We’re not saying SaaS dies. But its position shifts.
| What we used to buy | What we now generate with AI |
|---|---|
| Automated testing platforms | Prompt-driven Playwright suites |
| Low-code form builders | Schema-based React form generators |
| Documentation tools | AI-maintained, usage-aware docs |
| Dashboard frameworks | SQL-to-chart UI scaffolds |
| Onboarding flows | Contextual prompt-generated walkthroughs |
This is infrastructure-as-prompt — and it’s moving fast.
📦 Why This Will Reshape Consulting
In the old model, consulting engagements often started with tool selection, followed by months of integration, configuration, and compromise.
In the new model, you don’t buy the tool — you describe the need. The AI builds the tool around the client's existing system, not the other way around.
Consultants will still be essential — but their value will shift:
- From implementing tools → to codifying reusable domain patterns
- From integrating platforms → to defining scaffoldable architectures
- From writing boilerplate → to designing self-healing prompt systems
This is what I’m calling Just-in-Time Software.
You don’t ship it once. You regenerate it on demand, each time sharper.
🧭 Questions We Need to Ask Now
- What becomes our new source of truth?
Is it still code? Or is it structured rules, schemas, and prompt systems? - How do we audit or version software that didn’t exist yesterday?
If an AI assistant generates 200 tests from a pattern file, what governs their correctness? - Where do budgets go when the marginal cost of a framework drops to zero?
Do we fund reusable prompt libraries? Domain-specific AI models? Execution sandboxes? - What becomes the consulting deliverable?
A working app? A prompt engine? A portable intelligence layer?
🏁 Where This Leaves Us
We’re not entering a no-code future. We’re entering a no-stagnation future.
Where every system is transient, every layer is regenerable, and every tool is a snapshot of an underlying pattern.
The firms who win won’t just integrate software — they’ll teach AI how to build and rebuild software that fits each client's exact needs, just-in-time.
I’ve lived that transition firsthand.
Now it’s time to scale it to the enterprise.
