To prepare for a deeply uncertain future, you need future-proof software. Companies that rebuild for continuous, accelerating change will operate faster than their competitors. The winners won't be those who predict the future, they'll be the ones who invent the future by building systems that adapt faster than their competition.
Our Core Beliefs
We believe the path forward requires a fundamental shift in how we think about software:
Adaptability beats prediction. You cannot predict what AI will enable in 18 months. You can build systems that adopt those capabilities within days of their release.
Specifications are durable assets. Your business logic, formally specified, is your intellectual property. It must be consolidated in a single place and structured for introspection.
Implementations are artifacts. Code should be a manifestation of your specifications in a particular technology at a particular moment.
Knowledge is power. How you organise knowledge determines whether humans and tools can reason about your business effectively.
AI-native companies will win not by predicting the future, but building systems nimble enough to adapt.
The Transformational Choice
You face a difficult choice: Continue incremental improvements to existing systems, accepting vendor lock-in and technical obsolescence, or rebuild your foundation for continuous regeneration.
The very nature of code is changing:
Treating business logic as the true source. Your specifications define what your system does. The programming language, framework, cloud provider, and AI models become swappable components rather than foundational decisions.
Building for continuous regeneration. When better technology emerges faster and faster, you regenerate your implementation from specifications. This will take weeks, not years.
Creating competitive advantage that compounds over time. Each regeneration gets faster. Each technology upgrade happens sooner. The gap between you and slower competitors widens continuously.
The Strategic Shift
Large Language Models cannot achieve this yet, but are showing great promise in being able to build entire systems given good specifications as input. This requires rethinking what truly constitutes your software assets:
Your specifications are your intellectual property. They capture your business logic, rules, workflows, and domain knowledge in a durable and technology agnostic form. They're version-controlled, reviewed, and tested like code because they are your source code.
Implementation code becomes a generated commodity. With modern AI, you generate working code from specifications. Java today, Elixir tomorrow, whatever makes sense next year. The specification should remain stable while implementations can change.
Knowledge structures become AI-accessible assets. Your data needs be stored and structured so humans and tools can reason about it. Every decision, interaction, and outcome becomes organisational memory that AI can access and learn from.
Systems are continuously regenerated from specifications. Technology changes happen through regeneration, not migration. When AI capabilities leap forward, you regenerate. When your cloud provider changes pricing, you regenerate. Your specifications stay stable; everything else adapts.
The business impact is profound:
Cost: Tech stack changes take weeks instead of years. No more multi-year, multi-million dollar modernisation projects.
Speed: Deploy new capabilities as they emerge. Your competitors take quarters; you take weeks.
Risk: Eliminate vendor lock-in and technical obsolescence. You're never trapped by yesterday's decisions.
Security: In a world where criminals will have better capabilities at an accelerating rate, security is not optional. Making an appearance on the front page of the news isn't what anyone wants, especially your customers.
Talent: Your best people become architects who define value, not maintainers fighting technical debt.
Principles for Future-Proof Software
The irony is that these are not new ideas and are just current best software best practices. But as we begin move even faster, the fundamentals matter even more than ever!
Specifications First
Treat specifications as first-class artifacts. Version-controlled, peer-reviewed, and tested for consistency. They're your single source of truth. Everything else generates from here.
Determinism at the Core
Frontier Language Models have improved dramatically giving us a taste of what might be possible, but they are still rolling the dice. Outcomes from non-deterministic tools aren't reliable enough. Leverage deterministic tools at the core of your systems and leverage non-determinism at the edges
Less is More
Counter-intuitively, code is not an asset, it's a liability. Every line of code is a liability requiring maintenance. Every dependency adds complexity. Every feature must be justified.
Ruthlessly cut complexity. Before adding anything, ask: is this necessary or merely convenient? Can we solve this with what we have?
Simple systems are adaptable systems and complexity is the enemy.
Avoid Lock In
Avoid irreversible decisions. Cloud vendor lock-in. Proprietary frameworks. Tightly coupled AI providers. These are concrete that hardens and traps you.
Use clouds for commodity compute, storage, and networking. Abstract everything else behind interfaces. When something better emerges, you can switch.
Systems That Track Everything
Store event sequences, not just current state. Every action that changes your system becomes an event. Current state is derived by replaying events.
This gives you complete audit trails and lets you understand who changed what and when. When business logic changes, replay events with new rules.
Modular Architecture
Build discrete, loosely coupled modules with clean interfaces. Each module encapsulates a specific business capability. Communication happens through stable contracts.
This lets you replace or update components without touching the entire system. Specifications naturally encourage modularity, and when you define interfaces explicitly, you create clean boundaries.
Abstract Dependencies
Wrap external services behind interfaces. Your business logic shouldn't mention Stripe or AWS or OpenAI directly. Create payment interfaces, storage interfaces, AI interfaces. The specific provider becomes an interchangeable implementation detail.
This applies to payment processors, databases, AI models, vector stores and anything external. It's extra code upfront but it pays dividends when you need to switch providers or when breaking changes happen.
Test Suites Ensure Reliability
When non-deterministic tools are being used to build systems, you're leaning on good tests harder than ever.
Specify what the system should do and create tests that verify those specifications are met.
Build Observability
Build logging, metrics, and tracing in from day one. You can't maintain what you can't understand.
This is especially critical for AI systems. When an LLM gives an incorrect answer, you need to trace back: what data was retrieved? What context was provided? What embeddings were used? What model responded? Without observability, debugging AI systems is impossible.
Small Teams Win
Large teams move slowly. Communication overhead scales exponentially. Small autonomous teams move with remarkable speed.
Everyone understands the context. Decisions happen naturally. Clear ownership emerges. Constraints breed elegant solutions.
A focused small team with clear specifications will outperform a large team managing complex legacy systems.
Why This Matters for AI
The AI landscape changes weekly. Models improve. Best practices evolve. Architectural patterns emerge and sometimes vanish in months.
Traditional software development assumes relatively stable technological foundations. You pick a stack and use it for years. AI breaks that assumption completely.
Specification-driven development thrives in this chaos. When implementation details change weekly, having a stable specification layer becomes invaluable. Your spec says "classify customer sentiment" the specific model, prompting strategy, and embedding approach become generation-time decisions, not baked-in assumptions.
Abstract your AI integrations. Today's best model is next month's commodity. Today's cutting-edge architecture is next quarter's anti-pattern. Maintain the flexibility to adopt improvements as they emerge.
How to Get Started
This transformation can't happen overnight. A practical way to get started is to begin with one domain, one new feature, or one problematic legacy component.
Write comprehensive, structured specifications. Generate the implementation and documentation using deterministic tools like Ash. Ensure determinism is at the core of your approach so that you build on solid foundations. Measure the impact through time saved, costs reduced, quality improved, and flexibility gained.
Then expand. Domain by domain, system by system. Small teams working on focused areas, each building on specifications. Each regenerating as better technologies emerge.
The organisations that move now will establish compounding advantages. Each quarter they adopt new AI capabilities faster than competitors. Each year the gap widens. Three years from now, they operate at a different speed entirely.
The question is not whether AI will fundamentally transform your business. It will. The question is whether your software can adapt fast enough to harness each wave of capability as it arrives.
Build systems nimble enough to adapt. Treat specifications as your durable intellectual property.
The future belongs to companies that can adapt faster than the future changes.
