AI Coding in Fintech: It's Not About the Code

Everyone's Talking About Code Generation. That's the Wrong Focus.

Ask a developer about AI coding tools and you'll hear the same thing: they're brilliant at spitting out snippets, but they fall apart when you bring them into a real enterprise. In fintech, the bar isn't just "does it compile?" It's "does it respect customer data boundaries, pass audit, and not leak sensitive logic through a misconfigured agent?"

That's the gap Li Weining, internal open-source lead at HSBC Technology, plans to address at AICon Shenzhen. His talk, "From Code Generation to a Full Development Loop: AI Coding in Fintech SDLC," isn't about prompt tricks. It's about turning AI coding from a personal productivity hack into a governed, organization-wide capability—with access control as the load-bearing wall.

Why Fintech Is a Different Animal

Financial software development carries a unique set of constraints. You're dealing with legacy core banking systems, strict regulatory reporting, and a zero-tolerance attitude toward data leaks. A model that confidently generates a query joining two tables might not realize one of those tables contains personally identifiable information (PII) that should never be joined in that context.

Li's background—15 years across HSBC, GAC Automotive Finance, Xiaopeng Leasing, and Hang Seng Bank—gives him a practical view of these pain points. He's not a researcher; he's the person who has to make AI work inside a bank's walls.

From Personal Assistant to Organizational Capability

The shift sounds simple but is anything but. Early AI coding adoption is individual: a developer installs GitHub Copilot in VS Code, gets suggestions, and feels faster. But that's a single point of value. The real payoff comes when the tool understands the project's architecture, the team's conventions, and the compliance rules—and when it can't access things it shouldn't.

HSBC's approach has been to build an internal open-source community around AI coding practices. Teams share their prompts, their failures, and their agent configurations. The good stuff gets standardized into reusable "Agent Skills"—packaged capabilities that can be invoked across projects.

Access Control: The Unseen Linchpin

Here's where access control enters the picture. An agent that can see all code, all Jira tickets, all Confluence pages, and all deployment logs is a security nightmare. But an agent that's properly scoped—that can only read certain repositories, only query specific APIs, only act within a sandboxed environment—becomes a trusted team member.

Li's talk will walk through how HSBC handles this. It's not just about setting a read-only flag. It's about granular permissions per agent skill, per environment, per user role. A developer in the payments team shouldn't have an agent that can access risk models from the trading floor. That's basic tenant isolation applied to AI.

Six Stages of the SDLC, One Governed Loop

The meat of the presentation is a stage-by-stage breakdown of how Agent Skills fit into the software development lifecycle:

Requirements: Context Is King

Agents pull from Jira and Confluence to summarize requirements, flag ambiguities, and suggest clarifying questions. But they only see the projects they're supposed to see. Access control at this stage prevents an agent from accidentally surfacing unrelated project details in a requirements doc.

Design: Architecture with Guardrails

When an agent helps generate an architecture proposal or analyze impact, it needs to reference internal standards and past design docs. Again, the agent's knowledge base is restricted to approved sources. No random internet crawling, no unvetted external dependencies.

Coding: The Familiar Boost

VS Code and GitHub Copilot integration is the most visible part. But even here, access control matters. The agent can suggest code that uses internal libraries, but it can't fetch packages from unapproved registries or read environment variables that contain secrets.

Review: AI as a Second Pair of Eyes

Code review agents check for common issues, security vulnerabilities, and style violations. They also verify that the code respects access control patterns—like checking that a new API endpoint doesn't accidentally expose admin functionality.

Testing: Closing the Loop

Test generation is useful, but the real value is in defect analysis. An agent can trace a failed test back to the likely code change, but it needs access to logs and traces. That access is time-boxed and scoped to the specific service, not the entire infrastructure.

Delivery: The Final Gate

Before anything goes to production, the agent helps with deployment checklists and post-deployment verification. It can also flag if a change violates a compliance rule—like a new data field that wasn't approved by the privacy team.

MCP and the Tooling Ecosystem

Li will also cover the Model Context Protocol (MCP), which is becoming the standard way to connect agents to external tools. MCP matters for access control because it defines how an agent asks for data and what permissions it has. HSBC has been experimenting with MCP to create a uniform access layer across VS Code, GitHub, Jira, and Confluence.

The goal is a single agent that can move across tools without juggling multiple credentials. But that also means the agent's identity becomes a security principal. You need to manage its tokens, its scopes, and its audit trail just like you would for a human user.

Governance: The Unsexy Part That Saves You

No talk about AI in fintech would be complete without governance. Li's slides will likely emphasize three things:

• Data boundaries: Agents must never see data they don't need. This means careful dataset curation and strict API permissions.
• Quality control: Agent outputs—whether code, tests, or summaries—need review before they're trusted. Not every suggestion is gold.
• Audit trails: Every action an agent takes should be logged. If something goes wrong, you need to know exactly which agent, with which permissions, did what.

HSBC has also built a review process for Agent Skills themselves. Before a skill is shared across the organization, it goes through a security review. That includes checking what external calls it makes, whether it can be tricked into prompt injection, and whether its outputs could violate regulatory requirements.

Scaling Without Breaking the Bank

The last part of the talk is about scaling. HSBC started with small internal open-source projects and gradually built a platform that now has thousands of contributors across the bank. The trick, Li says, is not to force adoption but to make it easy for teams to share and reuse what works.

That means building a community, providing training, and—crucially—making the access control model simple enough that teams don't need a security expert to configure their agents. The platform handles the heavy lifting: role-based access, environment isolation, and automated policy checks.

What You'll Walk Away With

Li's session is aimed at anyone trying to move AI coding from a demo to a production system in a regulated environment. You'll learn how to structure an internal open-source community, how to turn scattered prompts into governed agent skills, and how to balance speed with safety.

If you're in fintech—or any industry where data is sensitive and mistakes are costly—this talk offers a blueprint for making AI coding not just useful, but trustworthy. The key insight is that access control isn't a constraint; it's what makes scale possible. Without it, AI coding will always be a risky experiment. With it, you can build a system that developers actually rely on.