From Sparks to Steady Flames: Firecraft Lessons from Fintech AI Coding

The Fire That Starts Small

Every fire begins with a single spark. In the world of AI coding, that spark is a lone developer generating a snippet of code. But as the fintech teams at HSBC discovered, a spark is not a fire. Turning a useful trick into a dependable, repeatable flame takes structure, patience, and a willingness to share what you've learned.

At the AICon conference in Shenzhen, Li Weining, HSBC's internal open-source lead, laid out a path from individual code generation to a full software development lifecycle (SDLC) revolution. His talk, titled "From Code Generation to R&D Closure: AI Coding in Fintech SDLC," wasn't just about tools. It was about firecraft—the art of building, controlling, and scaling fires that don't go out when the wind shifts.

Why Fintech Is a Hard Place to Make Fire

Fintech isn't a dry forest. It's a rain-soaked, wind-blown ridge where one mistake can start a wildfire. The challenges are real: model outputs can hallucinate, producing confident nonsense. Security and compliance loom over every line. And scaling a tool across teams with different stacks and workflows is like trying to teach fire-making to a village where everyone uses different wood.

Li's team faced these exact problems. They had developers using AI to write code faster, but the results were inconsistent. In complex business scenarios, code quality varied. Sensitive data could leak. Tools might overstep their permissions. And even when a solution worked for one team, it didn't easily transfer to another. Sound familiar? It's the same problem every fire-tender faces: what burns well in one place may not catch in another.

Building a Shared Fire: Internal Open Source

The answer, Li argues, is internal open source. Instead of letting each team hoard its own spark, HSBC created a community where teams could share their AI coding experiences. This wasn't about collecting random prompts in a shared drive. It was about turning scattered knowledge into reusable tools and Agent Skills—like crafting a standard fire drill that everyone can use, rather than everyone fumbling with their own sticks.

The process was iterative. Teams contributed their best practices for requirements analysis, architecture design, coding, review, testing, and delivery. Over time, these practices were refined into tools that could be governed and reused. The result was a platform that thousands of people could share and build upon. It's a far cry from the lone developer with a clever prompt.

Agent Skills: The Fire Tools of the SDLC

Once you have a shared fire, you need tools to control it. Li's team developed Agent Skills—specialized capabilities that plug into different stages of the SDLC. Think of them as different fire tools: a bellows for kindling, a poker for logs, a bucket for water when things get out of hand.

Requirements: Reading the Wind

In the requirements phase, agents connected to Jira and Confluence help teams understand and clarify what's needed. They pull context from project docs, flag ambiguities, and suggest clarifications. It's like reading the wind before you light a match—knowing which direction the smoke will blow saves you from a face full of ash.

Design: Drawing the Fire Plan

During design, agents assist with architecture generation, impact analysis, and technical decisions. They can propose options based on existing patterns, highlight risks, and help teams weigh trade-offs. It's not about replacing the architect—it's about giving them a better map of the terrain.

Coding: Feeding the Flames

In the coding phase, agents integrated with VS Code and GitHub Copilot speed up development. They complete code, suggest fixes, and keep the momentum going. But here's the key: they don't just generate code. They maintain context—the fire's memory of what's been built and why.

Review: Checking the Burn

Code review gets a boost too. Agents help spot risks, enforce style rules, and catch issues a human might miss. They act as a second set of eyes, like a seasoned fire-watcher who notices a spark that's about to jump the line.

Testing: Ensuring It Holds

Finally, in testing, agents generate test cases, analyze failures, and close the loop on verification. They help ensure the fire burns steadily, not just brightly for a moment. A test that catches a regression is like a firebreak that stops a small flame from becoming a disaster.

Tools That Connect: MCP and the Fire Circle

None of this works without integration. Li highlighted MCP (Model Context Protocol) as a way to connect tools, data, and the developer's context. Instead of a single assistant that does one thing, you get a workflow where agents move across tools—from VS Code to Jira to Confluence—picking up and dropping off information like a relay team carrying water to a fire.

This is the difference between a single spark and a sustained blaze. A lone tool can generate code, but a connected system can manage the entire lifecycle. MCP acts as the fire circle, keeping all the elements in one place so they can work together.

Controlling the Fire: Safety and Governance

Fire is useful, but it's also dangerous. In fintech, the stakes are high. Li's talk emphasized safety, compliance, and data boundaries. Agent Skills need governance: who can use them, what they can access, and how they're audited. It's not about smothering the fire—it's about keeping it in the pit.

They balance efficiency with risk. For every speed gain, they ask: what could go wrong? What data might leak? What action might a tool take that it shouldn't? This isn't paranoia; it's the same respect a fire-tender has for a flame. You don't invite it into your home without rules.

Scaling the Fire: From Pilot to Practice

The hardest part, Li admitted, is scaling. Starting small is easy—a single team, a single tool. But moving from a pilot to an organization-wide platform takes more than good tech. It takes a shift in culture. Developers need training, feedback loops, and a community that rewards sharing.

HSBC's approach was to start with high-value pilots, then create a path that others could follow. They built a platform that thousands could use, not just a few. And they didn't force it. They let the fire spread naturally, one team at a time, proving value before asking for adoption.

What Firecraft Teaches Us

Li's talk wasn't just about AI coding. It was about a mindset: that any tool, no matter how promising, needs to be built into a system that people can trust. It needs to be controlled, shared, and scaled with care. That's firecraft.

Whether you're tending a campfire or rolling out AI across a bank, the principles hold. Start small. Learn from others. Build tools that fit your hands. Respect the risks. And never forget that a fire is only as good as the people who tend it.

The AICon conference, with its ten tracks on AI infrastructure, agents, and embodied intelligence, is a testament to this shift. The future isn't about bigger models—it's about building reliable systems around them. And that's a lesson any fire-tender can appreciate.