The short answer
Transmitting proprietary code to a third-party AI assistant generally constitutes a third-party disclosure under standard Non-Disclosure Agreements (NDAs), unless the AI provider acts strictly as a data processor under a business agreement that mirrors your confidentiality obligations.
Using consumer AI tiers (free or standard individual subscriptions) on client code almost certainly violates standard non-disclosure terms, because those tiers reserve rights to store, review, or train models on submitted inputs.
The legal anatomy of an NDA breach via AI
Non-Disclosure Agreements are designed to restrict the disclosure of confidential information to unauthorized third parties. When an engineer uses an AI coding assistant, source code leaves the local machine and travels to the vendor’s cloud infrastructure.
Whether this constitutes a breach depends on three contractual factors:
- Definition of Confidential Information: Most NDAs broadly define confidential information to include source code, system architecture, database schemas, algorithms, and unreleased product features.
- Definition of Permitted Disclosures: NDAs permit disclosure to employees and contractors who “need to know” and are bound by confidentiality obligations at least as restrictive as the NDA itself. Third-party SaaS vendors are not automatically covered by this exception unless specific vendor processing terms are in place.
- Vendor Data Rights: If the AI vendor’s terms permit human review of prompts, model training on customer inputs, or sub-processor sharing without notice, transmitting the code breaches the confidentiality obligation.
Why individual paid accounts do not protect you
A common assumption among developers is that upgrading to a $20/month individual subscription waives vendor data usage rights. As detailed in our breakdown of free vs paid AI tools terms, individual paid plans operate under consumer terms of service.
Under consumer terms:
- The vendor may retain prompts for extended abuse monitoring windows (typically 30 days or longer).
- Human trust and safety operators may review flagged prompts.
- Sub-processors may be utilized without prior notice to or consent from the customer.
If a client NDA prohibits third-party disclosure, sending client code to a server where human contractors or unapproved sub-processors may inspect it breaks the agreement, regardless of whether model training is toggled off in settings.
Trade secrets vs. general confidentiality
Beyond standard NDAs, proprietary software often relies on trade secret law for protection. To maintain trade secret protection under legal frameworks (such as the US Defend Trade Secrets Act or the EU Trade Secrets Directive), the owner must exercise “reasonable measures under the circumstances” to keep the information secret.
Pasting proprietary algorithms or unannounced business logic into consumer AI assistants can be argued in court as a failure to exercise reasonable measures. Once a trade secret is disclosed to a third party without strict, enforceable confidentiality controls, its legal status as a trade secret may be permanently forfeited.
What client contracts say about subcontractors and SaaS
Enterprise software contracts and client master services agreements (MSAs) frequently contain specific clauses governing third-party tools and subcontractors:
- Subcontracting Restrictions: Many client contracts specify that using third-party cloud services to process client code constitutes subcontracting, requiring prior written client consent.
- Data Residency & Cross-Border Transfer: Client MSAs may restrict code processing to specific geographic regions (such as the EU or US). Consumer AI tiers rarely offer contractual guarantees regarding where inference occurs.
- Audit Rights: Client agreements often give clients the right to audit security practices and tool usage. Using unapproved consumer AI tools creates an unresolvable audit finding.
Technical controls for working under an NDA
If you work on confidential codebases or client projects, implementing technical guardrails is essential to prevent accidental disclosures:
1. Repository-Level Path Exclusions
Ensure your team configures repository exclusion rules to block the extension from inspecting sensitive files, context buffers, or configuration files. Learn how context collection works in our guide on what your IDE extension sends that you didn’t type.
2. Local Self-Hosted Models
For strict zero-disclosure requirements, deploy local open-weight models running on local hardware (or isolated air-gapped infrastructure). Local inference ensures that code never leaves the developer’s workstation.
3. Enterprise Workspaces with Custom DPAs
If cloud AI assistants are necessary, use enterprise workspaces governed by a commercial agreement that includes:
- Explicit confidentiality commitments matching or exceeding your client NDA.
- Zero-data-retention (ZDR) options or strict ephemeral processing.
- Complete exclusion from model training datasets.
- A signed Data Processing Addendum (DPA).
Recommended action plan for developers and agencies
- Audit your current AI tool usage: Identify whether developers are using personal accounts on client codebases.
- Review your client contracts: Check existing NDAs and MSAs for specific clauses regarding third-party SaaS processing and subcontracting.
- Establish a clear internal policy: Define explicitly which AI tools and tiers are approved for proprietary code versus open-source work.
- Obtain written client authorization: When in doubt, request written confirmation from the client or security officer before enabling AI extensions on proprietary repositories.
Disclaimer: This guide provides technical and contractual security analysis, not formal legal advice. Consult qualified legal counsel for specific contract interpretations.