When Claude Code writes a function, refactors a service, or scaffolds an entire feature, someone still has to answer for it. Not in the abstract sense of AI ethics, but in the concrete sense of a git blame, a code review sign-off, and, if something breaks in production, a support ticket with a name attached. Australian software teams adopting agentic coding tools are running into this question faster than legal guidance can keep up, and the answer matters more than most teams assume.
Copyright doesn't care who typed the code
Under the Australian Copyright Act 1968, copyright protects works with a human author. Case law on computer-generated material has consistently required some form of independent human intellectual effort for a work to attract protection. A function that Claude Code writes end to end, with no material human input beyond a short prompt, sits in a genuinely uncertain spot for authorship. If your business depends on protecting the code your team ships as intellectual property, that's not a minor detail. It's a reason to keep a record of the prompts, the review comments, and the edits a developer made after the agent's first draft, because that record is what turns an agent-generated file into work your business can credibly claim as its own.
Contracts were written for humans, not agents
Employment agreements typically assign intellectual property created in the course of employment to the employer. Contractor agreements usually do the same for anything produced in performing the services. Both assumptions get shaky when the actual authorship is a large language model prompted by a person who may or may not have written a single line of the output themselves. A Sydney fintech we worked with discovered this the hard way: a contractor had generated core pricing-engine logic through Claude Code on their own personal subscription, outside the client's monitored environment, and the resulting dispute over ownership and confidentiality cost close to $18,000 in legal fees to resolve, before anyone touched the actual bug that started the conversation.
The fix isn't complicated, but it does need to happen before the first Claude Max seat gets handed out, not after a dispute. Contracts and policies need to state plainly that work produced with the help of an AI coding assistant, on company infrastructure or company time, belongs to the business the same way any other work product does.
What accountability actually looks like
Ownership and accountability are two sides of the same coin. If your business claims the code, it also owns what happens when that code fails. A few practices we recommend to every Australian client rolling out Claude Code across an engineering team:
Require a named human reviewer to approve every pull request touching production code, regardless of who or what wrote the first draft.
Keep the prompt history and reviewer notes attached to the commit, not just the diff, so provenance survives a later audit.
Update employment and contractor agreements to state plainly that AI-assisted output belongs to the business.
Treat agent-authored code exactly like a junior developer's code for testing, staging and sign-off, with no shortcuts because the model probably got it right.
Log which model and version produced a change, the same way your team already logs a compiler or dependency version.
None of this is about distrust of the tool. Claude Code genuinely speeds up the unglamorous parts of software work: the boilerplate, the test scaffolding, the migration scripts, the repetitive refactors nobody wants to volunteer for on a Friday afternoon. The risk isn't the code itself. It's teams treating agent output as a free pass on the review discipline they'd apply to any other contributor, junior or senior, human or otherwise.
The framework we use with clients
When we help an Australian business set up Claude Code across a development team, whether that's a five-person startup in Brisbane or a fifty-engineer platform team in Melbourne, we insist on a short written AI-code policy before the first seat is provisioned. It covers who reviews what, how prompts and outputs get logged, and how the existing employment and contractor paperwork gets amended to close the ownership gap described above. It typically takes a day to draft and agree, well short of the $18,000 a dispute costs once lawyers get involved, and it saves the awkward conversation about who actually owns a disputed pull request six months later.
If your team is scaling up Claude Code and hasn't settled who owns what an agent writes, that's worth a conversation before the first contractor dispute, not after. Book a time to talk it through and we'll walk through a policy that fits how your team actually ships code.
