AI & InnerSource
InnerSource's new BFF… or Secret Nemesis?

Cover illustration: AI as BFF and nemesis
Cover illustration: AI as BFF and nemesis
InnerSource Commons
InnerSource Commons
Photo of Matthieu Vincent
Photo of Matthieu Vincent

Matthieu VINCENT

Lead Platform Engineering

Two teams, one reflex

2026, 3 months apart. Same need: mask personal data in the logs before the GDPR audit.

Each team asked its AI assistant to write it.

Result: two vibe-coded libraries, two lists of sensitive fields, zero shared lines.

Sound familiar?!

On the agenda

  1. So, where does AI fit in?
  1. AI: InnerSource's BFF? 👼
  2. …or its Secret Nemesis? 😈
  1. The guardrails to put in place
  2. So: BFF or Nemesis?

01

So, where does AI fit in?

Angel and devil AI mascot saying hello
Angel and devil AI mascot saying hello

What changed in a few months

  • An assistant that reads unfamiliar code and explains it in 10 seconds
  • An assistant that generates a feature, its tests and its documentation, in a few minutes
  • An agent that opens a merge request on its own
  • A chatbot that answers any question
    • even over 10+ years of documentation, in a few minutes

It's no longer an autocomplete gadget.

It's a "colleague" that codes, reads and writes.

What does it have to do with InnerSource?

You know the 4 InnerSource principles by heart. Let's hold them up against what AI can do.

  • 🔓 Openness 👉 AI can search, summarize and connect what already exists
  • 🪟 Transparency 👉 AI can recover the why behind code, even without documentation
  • 🤝 Prioritized mentorship 👉 AI can guide a newcomer through unfamiliar code, at any hour
  • 🎁 Voluntary code contribution 👉 AI can generate code that follows given inputs and standards

Hence the question:

BFF or secret Nemesis?

02

AI: Best Friend Forever?

Angel AI mascot
Angel AI mascot

Openness
finding what exists, agents included

Before contributing, you first need to know the project exists.

With an AI assistant fed by the internal catalog, you can:

  • quickly find out whether a project "already does this" or something close, and who maintains it
  • see which other projects already use it
  • also find other teams' agents, prompts and skills: an agent is an InnerSource component like any other
  • reuse another team's skill that checks a merge request doesn't write personal data to the logs, rather than rewriting one

We've never been short of reusable components.

We've been short of ways to find them.

Transparency
living documentation

Often, the main debt of an InnerSource project: documentation.

With AI, you can:

  • Turn merge request and issue discussions into decisions everyone can read
  • Generate the README from the actual code, not from an assumption, and keep it up to date
  • Automatically summarize changelogs, progress and roadmap for guest teams
  • Retrodocument existing code that lacks documentation for a long time

Generated docs still need reviewing.

But docs to review is better than no docs.

Mentorship
a first mentor, available at any hour

Mentorship is prioritized in InnerSource… but Trusted Committers' time never is.

With AI, a new contributor can:

  • get the project's architecture, conventions and history explained, right when they need it
  • ask the "dumb" questions without fear of bothering anyone
  • get guidance on a first patch, even an imperfect one

AI absorbs the repetitive questions.

The Trusted Committer keeps their time to pass on what matters and validate contributions.

Contribution
shared gains

Contributor

Without AI - "I don't know this code, I don't dare touch it."

With AI - a first patch that follows the project's standards, with its tests, ready to be proposed.

Maintainer

Without AI - review, the real bottleneck of InnerSource: maintainers have to find the time and the headspace to do the job properly.

With AI - an automated first review pass that sends a first batch of feedback to the contributor, and a merge request summary that finally explains the "why" and the points to watch.

Contributing becomes a choice again, not an act of courage.

And the maintainer finally has time to say yes… or no.

👼 The scenario, BFF version

One possible future: 6 months later, a 3rd team has to pass the same GDPR audit.

Basic use of a generic AI

  • 10 messages to find the right contact
  • 2 days to get access to the code and understand it
  • Contribution probably abandoned or never reviewed… or worse: a new vibe-coded masker, because it's easier

AI plugged into the InnerSource catalog

  • One search in the catalog: the masking library already exists, with the company's data classification
  • A quick read of the documentation, up to date
  • A first patch proposed in 10 minutes, thanks to the skills and agents available in the project
  • Merge request opened on the existing component, not next to it - and reviewed by the maintainer the same day

Between the two columns, it's not the AI that changes. It's the quality of the context we give it.

So… BFF forever?

Across the 4 pillars, AI can be the accelerator of the InnerSource loop:

  • 🔓 Openness - know what exists before writing, agents included
  • 🪟 Transparency - docs and decisions that finally keep up with the code
  • 🤝 Mentorship - a first mentor at any hour, Trusted Committers freed up for what matters
  • 🎁 Contribution - propose without hesitating… and get it reviewed

But everything we've just seen assumes one thing:

that the human and the AI know what already exists.

And that's where it gets tricky… 😈

03

…or Secret Nemesis?

Devil AI mascot
Devil AI mascot

Openness
reinventing the wheel, at full speed

A generic AI assistant doesn't know your internal catalog. By default, it follows orders and makes things up.

So, naturally:

  • Ask it, and it regenerates a regex-based masker…
    • rather than suggesting the library that already knows the internal data classification
  • Every team, every dev gets "their own" solution, faster than ever
  • Same for agents: everyone builds their own, with their own sources, rules and security level, invisible to others
  • The number of parallel implementations goes up instead of down - code and agents

AI doesn't reduce duplication. It industrializes it.

Transparency
the why disappears

  • Decisions are no longer made in the issue, but in a private conversation with an assistant
  • The prompt and the context are neither versioned, nor reviewed, nor shared
    • the code shows up, but the "why" exists nowhere
  • Architecture choices look plausible… but nobody can say who made them, or why

Yesterday, we debated in the issue.

Today, we debate with our assistant - and nobody sees the discussion.

Mentorship
the illusion of autonomy

  • "AI will know how" replaces "I'll ask the people who know"
    • yet with thin context, AI makes up a plausible answer rather than admitting it doesn't know
  • Trusted Committers no longer pass knowledge on: it stays in their heads… and the next generation doesn't get trained
  • The collaboration reflex withers: we produce fast, alone… and unlearn how to cooperate

AI makes us more autonomous…

and collectively more fragile.

Contribution
the race for volume

  • A flood of generated contributions, with little context and little control
    • imagine 10 MRs opened in one hour where there were 2 a month a year ago
    • no more maintainers to review and validate them… hence the temptation to delegate review to AI
  • Agents opening MRs in bulk: the host team no longer chooses what it receives, it endures it
  • An AI-generated contribution without serious human review, and trust in the "contributor" and "maintainer" badges quickly erodes

AI democratizes contribution and puts even more responsibility on maintainers' shoulders.

A maintainer's value is no longer measured by the contributions they accepted, but by the ones they knew to refuse.

😈 The scenario, Nemesis version

The other future: back to our two teams, and their personal data masking.

Each one, with its own assistant and its own prompt, vibe-coded its own internal library - and even its own test suite.

… a few hours of development, twice, 3 months apart…

… then comes the audit: the same leak on both sides, IBANs typed with spaces slip through both masks. Same model, similar prompts: same bug. And it's the auditor who tells each team that the other one exists.

Two libraries: one leak, two fixes.

One shared component: one leak, one fix.

04

The guardrails to put in place

AI can "optimize" every team, every dev, locally, at lightning speed - while silently fragmenting the whole.

The real risk: that it's very effective in the wrong places.

Openness
provide the context

  • Plug AI into the real assets (index / RAG, MCP server on the catalog) so it suggests what exists before generating
    • project source code, technical and functional documentation, backlog and ticket history
  • Document for humans and for agents: a versioned AGENTS.md, a structured README, CODEOWNERS as the source of truth for ownership
  • Publish agents, prompts and skills to the catalog like components, with a maintainer
    • when team A's agent gets it wrong at team B, we know who owns the bug
  • Make "search before you generate" a team norm, and track the reuse rate (consuming teams, MRs from other teams)

Open doesn't mean open to everyone: the agent must inherit the permissions of whoever queries it, otherwise the catalog becomes an exfiltration channel.

Transparency
adapt governance

  • Keep decisions in the issue or the merge request, not in the chat with the assistant
  • Version the prompt and the context next to the code - that's where the "why" lives
  • Label AI-assisted contributions: a checkbox in the merge request template, without turning it into a trial
  • Decide and control, as a team, the level of autonomy given to agents

The code says what was done.

The versioned prompt and context say why and how.

Mentorship
AI assists, humans pass it on

  • AI answers first-level questions, the Trusted Committer keeps dedicated time to guide contributors
  • Make review a moment of knowledge transfer, not a rubber stamp: explain rejections, don't just flag them
  • Connect AI to the people who know, don't replace them: it cites the doc, the issue and the person to contact
  • The contributor must be able to explain their merge request without their assistant

An MR its author can't explain isn't a contribution.

It's a code drop.

Contribution
human in the loop

  • AI proposes, the human decides and signs the contribution
  • AI does the first pass, the Trusted Committer does the review, with the same bar: quality, security, tests
  • Against the flood: an issue discussed before any generated MR, a CONTRIBUTING.md that requires context (need, linked issue, tests)
  • Attribution stays clear: who contributed, not just which model generated the text

AI can write the contribution. It can't sign it.

Signing means committing.

What does it look like in practice?

An AGENTS.md, read by humans and by agents:

🔓 Before generating
- Search the internal catalog first (MCP server "catalog")
- A component exists? Propose a contribution, not a new project

🪟 Decisions
- Design choices go in the issue, not in the conversation
- Version the prompt and context in prompts/, next to the code

🤝 Guidance
- Trusted Committers: @data-privacy-team, office hours on Tuesdays
- Don't know? Say so, and point to them rather than making things up

🎁 Contribution
- No merge request without a previously discussed issue
- Label the MR "AI-assisted": its author must be able to explain it

A guardrail written in the repo: every assistant reads it.

05

So: BFF
or Nemesis?

Cover illustration: AI as BFF and nemesis
Cover illustration: AI as BFF and nemesis

It's not AI that decides

AI is neither InnerSource's BFF nor its nemesis. It's an amplifier, so it can tip one way or the other depending on how we use it.

Like any BFF, it'll happily help you… make bad decisions faster.

Our two scenarios are the two possible trajectories:

  • Discoverable catalog + well-fed and controlled AI = shared contributions, under control, and less duplication
  • Silos + wild AI = uncontrolled duplication

The question was never "BFF or Nemesis?".

It's "what do we give it to amplify?"

Where to start, concretely

  1. Register a pilot repo in the catalog: code, docs, CODEOWNERS and agents
  2. Only then, plug assistants into it via an MCP server, with the user's permissions
  3. Write the pilot's AGENTS.md: the 4 guardrails, in black and white
  4. Version prompts and context, and set the agents' autonomy level
  5. Require an issue before any generated MR, an AI label and a human review, reserving time for Trusted Committers to guide contributors
  6. Track the reuse rate, not just velocity

As long as we measure what we produce, AI will produce.

Let's measure what we reuse, and it will search first.

Thank you!

Matthieu VINCENT - Lead Platform Engineering, Sopra Steria

https://me.yodamad.fr

https://innersource-commons-26.yodamad.fr

InnerSource Commons
InnerSource Commons