The starting point
A regional mortgage lender runs its technology on a lean footing: a four-developer team, Azure DevOps infrastructure, and a business environment — the mortgage market — that punishes slow, expensive software delivery. Leadership’s question to Node8 wasn’t “should we try AI coding tools?” It was sharper: how do we get materially faster feature delivery from the team we already have, without sacrificing the control a lender needs?
Two constraints shaped everything. First, the company prefers to invest in its existing team rather than outsource development or grow headcount — the four developers know the domain, and mortgage lending domain knowledge is expensive to replace. Second, this is a regulated industry: whatever the new process looks like, it has to be transparent, reviewable, and at least as safe as the current one.
What Node8 proposed
Across two working sessions — an initial follow-up on Claude Code and a full review of the AI-native development system proposal — the engagement took shape as a system build plus enablement, in three modules:
- Understand the current environment. Map the team’s actual SDLC: repos, Azure DevOps pipelines, CI/CD state, testing practices, and how work flows from request to release. AI-native development gets grafted onto the real process, not a whiteboard version of it.
- Build the system. Stand up Claude Code across the team with the integrations that make it effective in this environment — connections to the codebase, work items, and pipelines (including MCP integrations where they fit), shared conventions like CLAUDE.md files per repository, and a unified, automated workflow so all four developers work the same way. Part of the value here is consolidation: one consistent CI/CD-backed process instead of four personal styles.
- Train the team. Weekly hands-on sessions with the developers — real tickets, not exercises — so the skills stick. This module exists because the human side is the actual risk: at least some of the team starts skeptical, and skepticism is answered by working sessions where the system ships something they’d otherwise have written by hand, not by slideware.
The delivery plan splits into two phases of roughly a month each. Phase one gets the end-to-end flow working: AI writing code and tests inside the team’s environment, developers reviewing. Phase two is optimization and production hardening — tightening the conventions, expanding coverage, and making the process durable after Node8 steps back.
The core shift: developers as reviewers
The centerpiece of the proposal is a role change. In the target workflow, developers don’t write most code directly — Claude Code produces the implementation and tests end to end, and the developers specify, direct, and review. Their expertise moves to the two places it compounds: deciding what should be built and whether what was built is right.
For a regulated lender this framing did real work in the conversation. Code review, CI/CD gates, and human sign-off are the controls the company already trusts; the AI-native system routes all AI output through exactly those controls. Nothing merges without a developer’s review. The process stays transparent — you can inspect what the AI did and why — and quality is tracked alongside speed, because faster delivery that destabilizes a lending platform is a net loss.
It also reframes the expected payoff. The time saved isn’t hypothetical: implementation and test-writing are where most of the four developers’ hours currently go, and those are exactly the activities the system takes over. Review is faster than authorship, so the same team covers more of the backlog — which is the whole business case for a lender that wants throughput without headcount.
The honest trade-off discussed
The proposal review didn’t dodge the alternatives. The client weighed a lighter option — coaching and training alone — against the fuller system build, with ROI as the explicit test: does the investment pay back in team effectiveness and feature throughput? Node8’s position is that training without a system produces enthusiasm that decays, and a system without training produces shelfware; the two-phase plan bundles both deliberately. To ground the decision, Node8 is also connecting the client with a company that implemented a similar AI-native system, so the client’s leadership can hear directly from practitioners rather than take a vendor’s word.
Where things stand
This engagement is at the proposal-to-kickoff stage: plan and module breakdown reviewed with the client’s technology leadership, a detailed work plan delivered, reference conversations being arranged, and a decision on scope in motion. No results to report yet — this page will be updated as the rollout produces real data. The rollout mechanics — setup, CLAUDE.md conventions, review workflow, guardrails, and measurement — are detailed in Adopting Claude Code Across an Engineering Team: A Practical Rollout Plan.
Work with Node8
Node8 designs and installs AI-native development systems for lean engineering teams — especially in regulated industries where transparency and control are non-negotiable. See our financial services and technology practices, or talk to us about your team.