These are my personal views drawn from recent experience in the fintech industry. This is not financial or investment advice.
The 7–10 Year Problem
There is a pattern that repeats itself in financial services every decade or so.
A new technology emerges. The broader software industry adopts it within a year or two. Startups build with it from day one. And then, somewhere between three and seven years later, a large bank quietly forms a working group to evaluate it.
I've heard this repeatedly from engineers across the industry — people who lived through the institutional debates around framework adoption. The conversations around Angular were long. By the time consensus formed and teams were trained, the broader industry had already moved on. React followed a similar path, though the cycle compressed slightly. The technology was proven, the community was enormous, the talent was widely available — yet the institutional decision cycle moved at its own pace, shaped by procurement processes, compliance reviews, vendor assessments, and the fundamental conservatism that comes from running systems where failure has regulatory and reputational consequences.
That conservatism is not irrational. But it creates a structural lag that is now being stress-tested like never before.
What's Different This Time
AI tooling — and specifically large language models applied to software development and compliance workflows — is moving faster than any technology cycle I have observed in this industry.
McKinsey's April 2026 fintech report puts it plainly: fintechs are deploying AI to build products in weeks that once took years, and for those institutions that have not yet moved decisively, the competitive gap is widening.
The gap between what is possible today and what most financial institutions are actively using is wider than it has ever been. And unlike the framework debates of the previous decade, which were ultimately about developer experience, AI tooling touches something more fundamental: the speed and cost of producing compliant, documented, tested financial software.
Where AI Tooling is Already Winning
From recent hands-on experience — and from watching how engineers at different levels engage with these tools — the clearest wins are:
Compliance drafting and gap analysis. Regulatory documentation is verbose, precise, and deeply repetitive. AI models handle this category exceptionally well. Feed a regulatory update into a model, receive a structured gap analysis against existing documentation within minutes. Global regulators are now converging on the expectation that if your platform uses AI to make a decision, you need to explain and defend it — the FCA, MAS, and US OCC are all moving in this direction. The irony is that AI is both the subject of this scrutiny and the most powerful tool for meeting it. Compliance needs to scale like software — and AI makes that possible.
Data visualisation and dashboards. Financial dashboards that once required weeks of design and development iteration — risk exposure charts, portfolio performance views, regulatory reporting interfaces — can now be scaffolded and iterated in hours. Spec-driven development, where you describe the visual output you need and let AI generate the component then refine it through conversation, compresses the design-to-implementation cycle dramatically. The quality of the first draft is high enough that the conversation moves to edge cases and data integration, not basic layout.
Test coverage. Financial software is chronically undertested relative to its criticality. AI-assisted test generation dramatically lowers the cost of adequate test coverage — given a function, produce edge cases, boundary tests, and regression tests. In codebases where test debt has accumulated over years, this is one of the highest-ROI applications.
PRD to implementation. The translation from a product requirements document to a working technical specification has always been a lossy process. AI models that can read a PRD, identify ambiguities, and produce a structured implementation plan compress something that historically took days into hours.
Onboarding legacy codebases. Large financial institutions carry codebases that span decades. AI tools that can navigate, summarise, and explain legacy code reduce the onboarding cost significantly.
Fundamentals Still Matter — More Than Ever
One thing worth saying clearly: AI tooling amplifies what you already know.
Engineers with solid fundamentals — who understand SOLID principles, separation of concerns, and how to design systems that can actually scale — get dramatically more out of these tools than those without that foundation. The agent can write the code, but it takes a trained eye to know whether the architecture behind it will hold under real conditions.
Good engineering judgement is not replaced by AI. It becomes more valuable, because the speed at which bad decisions compound is now much higher. A poorly designed API contract, an unmigrated schema, a missing abstraction layer — these have always been expensive to fix. With AI tooling accelerating delivery, the cost of getting the foundations wrong arrives faster than it ever did before.
Build the right thing first. AI will help you build it fast. In that order.
The Agent Paradigm — This is Where It Gets Interesting
The single most underappreciated development in AI tooling right now is the shift toward multiple agents working in parallel on a single codebase.
AI orchestration is moving beyond isolated pilots. Instead of relying on one model for one narrow task, engineers are building systems where multiple agents work together across a codebase simultaneously — each bounded, focused, and working from the same shared contracts.
I've been exploring this directly — experimenting with spec-driven development, skills patterns, and MCP servers as part of my own build process. The pattern that is emerging, and one I find genuinely compelling, uses git worktrees — a feature that allows multiple working copies of a repository to exist simultaneously — to run separate agents on isolated branches, each handling a distinct part of the system at the same time:
- One agent working on API design and contract definitions
- A second handling database migrations and schema changes
- A third building front-end integration against the new contracts
- A fourth writing documentation as the code evolves
- A fifth running and expanding the test suite
These agents work in parallel without stepping on each other. They communicate through the shared codebase — the API contracts, the type definitions, the test assertions. The coordination overhead that normally dominates complex feature development shrinks dramatically.
Honestly, this is one of the most significant productivity gains I have seen in software development in years. Not incremental improvement — a genuine step change. A feature that would have taken a week to implement properly, with API, database, front-end, tests, and documentation all done to production standard, can be done in a day. The quality doesn't drop because each agent is focused, the context window is clean, and the scope is bounded.
In regulated fintech, this matters enormously. The key requirement is clean API layers, unified data models, and explainable decision logs so that agent activity can be audited.
The audit trail is not an afterthought. It is the design.
The Scalability, Performance, and Security Concern
These concerns are legitimate and should not be dismissed.
Scalability. AI-generated code can be inconsistent in its approach to scalability. A model that produces a working solution may not produce an optimal one at volume. Human review remains essential for any code that will operate at financial system scale.
Performance. AI tooling optimises for correctness and readability before performance. In latency-sensitive financial applications, this requires deliberate oversight.
Security. This is the most serious concern. AI systems must be explainable, infrastructure must be resilient, and compliance must be automated — these are the three technical realities of fintech development in 2026. AI models can introduce subtle vulnerabilities through pattern-matching on training data that includes imperfect code. Security review of AI-assisted code is not optional in financial services.
None of these concerns argue against using AI tooling. They argue for using it with appropriate review processes — which is exactly what good engineering practice requires of any code, regardless of how it was produced.
The Competitive Consequence
Fintechs lead incumbents by 47% to 30% in the adoption of advanced AI, and in reaching a transforming stage of adoption (19% versus 6%). Workforce preparedness and AI investment levels are the key differentiators.
The fintech startups building with AI tooling today are not just moving faster. They are building with smaller teams, lower costs, and higher output quality than was achievable three years ago. A compliance function that took fifteen people can now be handled by five with the right tooling. A development team that needed twelve engineers to ship a complex financial product can now ship with six.
The incumbents are aware of this. The response, in most cases, is to form a working group.
History suggests they have between two and five years before the competitive gap becomes a strategic problem rather than an operational one. The institutions that move now — not to replace their core systems, but to instrument their surrounding workflows with AI tooling — will be in a materially different position than those who wait for the working group to report back.