Goldman Sachs 4 min read

The Hard Part of AI Coding Starts When the Script Works

Key takeaways

  • Whether Goldman Sachs restricts Claude Code, and on what terms, remains uncertain.
  • The ability to write code does not confer permission to connect it to business systems.
  • Financial software needs checks on calculations, data access, and changes.
  • Tools built by nondevelopers need a clear path from experimentation to approved everyday use.

A trader who spends every morning wrestling with spreadsheets has an obvious reason to try an AI coding tool: make the repetitive work disappear. The harder question comes after the script runs successfully. Who decides whether everyone else can trust it?

The person closest to the problem can build the solution

Imagine a trader who combines transaction files, extracts a few columns, and checks which numbers have changed since yesterday. It is tedious work with a reasonably clear specification.

That trader knows where the friction is. They can explain what the output should look like and which exceptions matter. A tool such as Claude Code can help turn that knowledge into working software.

But one successful run proves surprisingly little. Tomorrow’s file might have different columns. A missing value might quietly disappear from a total. A script that worked perfectly on Monday could produce a plausible but incomplete report on Tuesday.

The promise is real: more people can implement their own improvements. The catch is that writing code and approving it for daily use remain separate jobs.

Permissions matter more than the product name

Whether Goldman Sachs actually restricts Claude Code, how broadly, and for what official reason remains uncertain. Treat such a restriction as a hypothetical, and the useful question becomes more specific: what would it prevent?

Blocking access to a coding tool is different from blocking its connection to customer data. Both differ from requiring review before a script enters daily use.

Consider the same program in two settings. In one, it processes fictional transactions in an isolated environment. In the other, it can edit live transaction records. The code might be identical. The consequences of a mistake are not.

A sensible policy would examine what the tool can read, what information it can send outside the firm, and what it can change. Read-only access deserves different treatment from permission to update records.

This is not an allegation that Claude Code leaks information. It is a question about access: permission to use a tool cannot reasonably mean permission to connect it to everything.

A polished report can still be wrong by 1,000×

Suppose a report confuses dollars with thousands of dollars. Every calculation could finish without an error message while the results are off by 1,000×.

The formatting might be impeccable. That is little consolation.

Finding the mistake requires more than checking whether the code runs. Someone must understand the units, business rules, and exceptions behind the numbers. The trader’s expertise remains essential during review.

Technical checks address another set of questions. Does missing data stop the program or produce a misleading total? Can an incorrect result overwrite a good one? Can the team restore the previous state?

Then there is ownership. If the person who built the tool moves to another department, someone still needs to maintain it. Changes need a record of what happened and who checked them.

AI assistance does not make those responsibilities disappear.

Give useful experiments a route into everyday work

I would set the review threshold according to the consequences of a mistake. A nondeveloper experimenting with fictional data should have room to learn. A tool that changes customer information deserves much closer scrutiny, regardless of who wrote it.

The route can be straightforward. Start with restricted access and sample data. If the tool proves useful, have a business specialist check the calculations and a technical reviewer examine permissions and error handling.

Before the team depends on it, assign an owner and establish how changes will be reviewed. Employees should know what it takes to move a promising experiment into regular use.

That is also how to judge any proposed restriction: identify the activity it blocks and the route it leaves open for useful work.

AI coding gives people closest to a problem more power to solve it. Turning that power into dependable productivity means checking the results and assigning responsibility. A successful script is a beginning; a tool the team can trust is the achievement.

Goldman Sachs Claude Code AI Governance

Comments

    Loading comments...