Goldman Sachs Pulls Claude Code From Traders After Four Months of Ungoverned AI Scripts
On a trading morning in October, a Goldman Sachs trader opened his terminal as usual, ready to ask Claude Code to help him modify a small script for monitoring the market. This time, the tool didn't respond to his account. No all-staff email, no training notice; the permission was simply switched off one night.
Four months earlier, the picture was completely opposite. In July, Goldman CIO Marco Argenti was publicly praising vibe coding by non-engineer employees, encouraging traders and bankers to use AI to turn ideas directly into tools, then hand them to engineers to polish, bypassing the old queue-for-development process. From encouraging the entire firm to revoking access took just one summer.
This is not a product story; it's an engineering story. What was revoked isn't an account for some software; it's a whole category of code that was never caught by engineering processes.
The problem is never AI; it's code nobody reviews
Many people's first reaction to this news is that AI-written code is indeed unreliable. That judgment is half right. The real problem isn't who wrote the code, but that these codes bypassed all the processes that should have caught them. Code written by engineers also has bugs, but engineers' mistakes are caught by layers of nets; traders' scripts have none.
The specific scenario Goldman worries about is concrete. Traders don't write scripts for fun; they track customer trading flows, model market positions, generate daily reports. Once written, these scripts run every day on computers that process customer information, becoming part of the business process. A program that no one has looked at now touches customer data daily.
AI completely changed the scale. In the past, a trader who wanted to automate something had to know how to code; that threshold naturally limited the number. Now the threshold is gone: thousands of untrained employees can let AI write programs for them, and they run as soon as they're written. The speed at which capability is distributed has far exceeded the speed of governance distribution.
No review means no one knows what's in the script. No testing means changing one line can miscalculate positions. No audit means if something goes wrong, you can't even find out whose script it was, what it changed, or what data it touched. No rollback means you can only stop losses manually. These four absences together are what Goldman truly fears.
So this isn't an AI trust crisis; it's a governance gap. The same models, the same tools, put in a pipeline with review and testing are productivity; put on an employee's computer without guardrails, they become a risk source. What Goldman revoked isn't trust in AI, but tolerance of an uncontrolled state.
Seeing this clearly, subsequent discussion becomes meaningful. Arguing whether AI-written code is good or bad is answering the wrong question. The right question is: does your process have the ability to digest code from any source, including AI, interns, and outsourcers? With proper processes, the source is neutral. Without processes, even the most reliable source can't be caught.
Why engineers' code can go to production
Similarly human-written code, why can engineers' version be deployed to production? Not because engineers don't make mistakes, but because their code goes through a series of gates from writing to launch. Each gate answers a specific question for the business.
First gate is code review. At least one bystander reads through the changes and asks questions the author can't think of. This step not only stops bugs but also design detours. Second is automated testing: changes must pass existing test suites before merging, ensuring old features aren't broken. Third is various static checks in CI: code style, security scanning, dependency audit.
Fourth is staged rollout: pre-production environment first, then small-traffic canary, then full. Fifth is monitoring and rollback: when online metrics are abnormal, can revert to previous version within minutes. These five gates form a trust chain. The business side doesn't need to trust any particular programmer; it only needs to trust the chain.
Key insight: this trust chain doesn't care who wrote the code. AI-generated code that passes the same five gates gets the same trust as hand-written engineer code. Conversely, engineer-written code that bypasses gates and goes straight to production poses the same risk as traders' scripts. The source of trust is the process, not authorship.
Goldman's own internal AI platform is built on that principle. The platform has built-in governance: data boundaries, permissions, and audit are designed in. The problem is outside the platform: traders use tools like Claude Code directly on their machines to generate agents and scripts; these outputs are naturally outside the platform's governance radius.
This is also the current state of many companies. Official platforms have guardrails, but employees actually prefer tools outside the guardrails because official platforms can't keep up with model vendors' release cycles. The time gap between governance and experience is where risk breeds.
Understanding the value of gates helps understand the real meaning of Goldman's adjustment. It's not a ban; it's a closing of the perimeter, pulling code scattered outside the guardrails back into the pipeline. The only question left is who bears the cost of closing the perimeter.
What Goldman actually changed
First, let's establish facts. According to Bloomberg, in October, Goldman revised its internal guidance, restricting access to Anthropic's Claude Code and Microsoft GitHub's AI coding tools to engineers. Before the revision, Goldman conducted an assessment of both productivity and risk; the conclusion was to tighten.
The majority of traders lost access. The things they used these tools for were concrete: tracking customer trade flows, modeling market moves and positions, generating daily reports. These are the needs closest to the business, exactly what July's vibe coding policy encouraged. Four months later, the same behavior was moved to the other side of the red line.
The core driver was security. Code written by engineers goes through review and testing before deployment, but code written by traders for watching customer trades could be used daily without any safeguards. Thousands of employees without development training write and run code on computers that handle customer information. Goldman's internal AI platform has these controls by design, but agents made by traders with external tools are not under control.
The real value in Goldman's new policy lies in three questions: Who is using AI, with what data, and under what terms? These three questions have no technical complexity, but most companies have never written clear answers. Goldman, an institution with 12,000 engineers, also completed its turn from loosening to tightening within four months, showing that the answers to these three questions can change very quickly.
There's also a dramatic detail. Goldman happens to be the lead underwriter for Anthropic's Nasdaq IPO this month. In the coming weeks, Goldman's bankers will be selling the stock of a company whose flagship coding tool most of them just lost access to. Commercial interests and internal security policy run in parallel within the same firm.
Reading this as Goldman opposing AI is a misreading. It hasn't banned AI; the internal platform remains, engineers' access remains. It banned the uncontrolled use of AI. This distinction is crucial for all subsequent discussion.
Goldman isn't the only one tightening
Goldman isn't alone; many people have spoken publicly. Replit CEO Amjad Masad recently made it clear on social media: AI agents running on employees' personal computers pose a systemic security risk to companies and governments, and some institutions have begun restricting tools like Claude Code. Goldman is just one of them.
The term systemic risk is heavy but accurate. A single script going wrong is a point issue; thousands of unreviewed scripts running simultaneously on thousands of computers is a systemic issue. Systemic issues have no single point of failure; they manifest as an overall elevation of data breach probability, and as gray areas that compliance audits can't explain.
Asian markets are also wrestling with this. Korean investment industry's situation was also reported. More investment review staff use AI for due diligence, analyzing investment contracts and investment committee meeting minutes. The demand is real: one reviewer manages dozens of portfolio companies and multiple transactions; manually processing massive materials isn't realistic, and you need AI to screen for early risk signals from existing positions.
But Korean institutions haven't solved trust either. One VC practitioner put it bluntly: employees are forbidden from using personal AI for work; the company supports signing enterprise AI contracts, but even so, a certain level of data leakage is considered unavoidable. Banning personal versions and buying enterprise versions is currently the only answer most institutions can offer.
Limitations of this answer are obvious. Enterprise contracts solve legal and data ownership issues, not engineering governance. Contracts stipulate data can't leave the country, but they can't control an employee letting AI write an untested script that touches production data. Legal guardrails and engineering guardrails are two layers; most companies have only built the first.
Smaller asset management firms are in even deeper trouble. Most lack dedicated security teams, internal platforms, or even staff to write an AI usage policy. Even Goldman with 12,000 engineers needed four months to reverse course; institutions with fewer resources will react even more slowly to the same risks.
Putting these signals together, the trend is clear. The period of crude, broad adoption is ending; the next is a period of governance catch-up.
Whoever has lower catch-up costs continues to enjoy the tool dividend. That's the problem engineering means need to solve.
The minimal engineering actions to put AI code under governance
Good news: governing AI code doesn't require inventing anything new; just apply existing engineering gates to AI code equally. The hardest first step isn't even technical; it's a rule: all code that will be executed must first enter a version control repository. Loose scripts on local machines don't count. Once code is in a repo, subsequent gates have a foothold.
I have personal experience. I maintain an automated release skill repository. Among the last fifty commits, forty-one were produced by AI agents; I specifically checked git log to confirm this ratio. These commits made it to mainline not by trusting the model, but because each one passed script self-checks and then manual review, treating AI code and human code equally.
On the tooling side, the first worthwhile thing is a pre-commit hook. It automatically runs checks before every commit; install once and it lasts. Installation is just two commands: first install the tool, then hook into the repository.
pip install pre-commit
pre-commit install
After installation, put a .pre-commit-config.yaml at the repo root, with secret scanning. The following config does two things: gitleaks scans commit content for secrets, tokens, private keys; pre-commit-hooks' detect-private-key adds another layer of private key detection. The rev field should be the latest tag from the corresponding repo's release page at configuration time.
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.28.0
hooks:
- id: gitleaks
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v5.0.0
hooks:
- id: detect-private-key
Why secret scanning first? Because the most common bad habit when AI generates code is hardcoding sample secrets and API endpoints directly in source. The model has seen countless examples with secrets in training data; it doesn't know which one is your real production key. Human review quickly scans but can miss; the hook intercepts before commit at near-zero cost.
After config, run a full scan: pre-commit run --all-files. The first run usually surfaces legacy issues. Export the report, confirm each whether it's a real secret or false positive; immediately revoke and rotate real secrets. After this, your repo has its first line of defense against AI code.
Significance of this defense goes beyond security. It sends a signal to the team that AI-written code isn't lawless territory; it has to pass the same gates as human code. Once that signal is established, the quality of AI output increases because the generation phase starts avoiding known restriction rules.
Add a static scan for AI code
Hooks manage the commit entrance; the second defense is static scanning, keeping an eye on code logic itself. Here I recommend semgrep, an open-source static analysis tool with rules selectable by language and framework. Installation is again one command: install directly in a Python environment.
pip install semgrep
semgrep scan --config=auto .
--config=auto means semgrep automatically pulls the corresponding rule sets based on languages detected in the repository; you get a baseline report with zero configuration. For more precision, you can explicitly specify rule sets, e.g., --config=p/python for Python projects, --config=p/security-audit for security-specific. These rule sets are maintained continuously by community and vendors, far more reliable than writing your own rules.
Why do AI codes especially need static scanning? Because models have their own statistical preferences, and these preferences include many unsafe practices. Ask it to write network requests; it might disable certificate verification. Ask it to write file handling; it might use overly permissive default parameters. Ask it to write command execution; it might paste external input directly into a shell string. These patterns work, they pass a quick human scan in review, but they don't pass rules.
Another value of static scanning is externalizing tacit knowledge. In a team, a senior can see problematic patterns at a glance; new hires and AI can't. Solidifying senior experience into rules means every line AI generates is checked against these rules, effectively having the team's most vigilant member review every commit without fatigue.
How to handle scan results also requires care. Alerting everyone directly results in alert fatigue; after three days no one looks. A feasible approach is tiered: high-risk rules block merging immediately; medium and low-risk rules generate reports but don't block, and are cleaned up at fixed times weekly. This way the security defense has teeth without dragging down development pace.
With both defenses in place, an ordinary repository has the basic capability to digest AI code. Secrets don't enter the repo, dangerous patterns don't pass gates, all changes are recorded. Total deployment cost is one person's afternoon; maintenance cost is near zero.
Compare cost and benefit. Goldman paid for risk control by revoking productivity tools from thousands. Small teams using this scheme pay two installation commands and a config file. Same governance, but engineering means cost far less.
Where governed and ungoverned differ
Compress the discussion into a comparison table, gap is clear. Left is typical state of trader scripts; right is what AI code should be after engineering gates.
| Dimension | Ungoverned vibe coding | AI code under engineering governance |
|---|---|---|
| Code review | Use immediately, no one reads | At least one engineer reads before merging |
| Test support | No tests; errors caught by eye | CI runs unit tests and static checks |
| Secret management | Might be hardcoded in source | Secret scan blocks before commit |
| Runtime environment | Employee's personal computer, next to customer data | Isolated environment or server-side sandbox |
| Data boundary | Send anything to external APIs | Data classification and authorization; boundaries in contract |
| Incident response | No logs, no rollback, accountability unclear | Audit trail, rollback possible, traceable |
The most underestimated row is the last. In an ungoverned state, when something goes wrong, the first scene is chaotic: whose script, what changed, what data did it touch, all with no record. With governance, git log plus audit logs answer these three questions within minutes, and stop-loss actions can start immediately.
The middle rows are a choice. Companies can spend heavily on internal platforms, or use open-source tools to build equivalent governance. pre-commit plus semgrep handle review and scanning; version control naturally provides audit; remaining runtime environment and data boundaries are more institutional design than technical procurement.
There's also a dimension not in the table: employee mindset. In ungoverned environments, employees feel unsure using AI, not knowing when they'll step on a mine. With clear governance, those within boundaries use AI more boldly because they know where the red line is. Clear governance isn't suppressing use; it's creating a safe zone for it.
This table can be used as a self-check list. Check your team's current state row by row; whichever row is still on the left is the week's homework. Suggested order is from top to bottom: fix review and secrets first, then environment and boundaries.
Homework small teams can copy
No 12,000 engineers, no dedicated security team, what can small teams do? Actually, the most valuable part of Goldman's new policy is free: the three questions. Who uses AI, with what data, under what terms. Write the answers into a one-page document, and most small teams' risk drops by half.
First question defines people: which roles can use AI coding tools, which roles can only use the internal platform. The basis isn't seniority; it's what data that role touches. Roles touching production and customer data get higher governance automatically. Second question defines data: divide team data into two categories, those that can leave and those that can't. Data that can't leave the domain is prohibited from entering any external AI dialogue box. Third question defines agreements: personal edition tools and enterprise contracts have completely different data terms; work scenarios only go through enterprise agreements.
Define people first, then data, then agreement.
After writing these three questions, add the two engineering defenses, and a small team's governance skeleton is complete. Material cost of the whole scheme is nearly zero; it requires someone to spend a day or two actually implementing it. In contrast, a blanket revocation of access seems easy but costs you the AI dividend.
To be honest, revoking access is the laziest answer among all. It avoids building governance by abandoning productivity, and governance is unavoidable. AI coding tools won't stop penetrating. Revoke Claude Code today; tomorrow a new tool will poke through another gap. Without engineering gates, bans just push the problem later.
My suggestion is concrete. Don't wait for the company to grow a security department. This week, do three things: gather loose local scripts into a repo, install pre-commit secret scanning, and write down the answers to those three questions. Any small team can afford these. Once done, you've gained something Goldman traded four months and thousands of people's permissions for: an engineering environment you can confidently use AI in.
Tools will get stronger; governance will only become more valuable. Those who install the gates first will be able to move fast confidently in the next wave of tool upgrades. This homework isn't hard to copy; the hard part is starting today.