← all playbooks

Map a company's engineering team from its public GitHub organisation

A map of each named company's public engineering footprint: repositories and languages, the people who contribute to each, who the maintainers are, and which of them look like staff. It is a floor, because much of any team is not visible.

use when
you are about to source from, or pitch to, a named tech company and want to know who builds what there before you open LinkedIn
starts from
A list

The prompt

Paste it into Claude Code or the Claude desktop app with Hyreflow connected. The first line tells your agent to use Hyreflow, so it reads the play, asks before it spends anything, and hands the work back to you.

paste this into Claude
Use hyreflow and map the engineering teams at these companies from their
public GitHub organisations.

The companies: <COMPANY_NAMES_AND_DOMAINS>
GitHub organisations, where I know them: <ORG_HANDLES>
I want this for <SOURCING_FROM_THEM_OR_A_PITCH>, and the part of the stack I
care about most is <LANGUAGES_AND_FRAMEWORKS>.

For each one:
- List the public repositories with language, stars and last activity.
- Pull the contributors per repository with commit counts. Drop bots.
- Read each person's public profile: name, stated employer, location,
  linked LinkedIn, their own repositories and languages.
- Tell me who looks like staff and who is an outside contributor, who the
  maintainers are, and show me the evidence for each call.
- Compare the count with the engineers the people databases list at the
  company, so I can see how much of the team is not visible.

Reading GitHub is free, so go wide on it. Run one company end to end first
and tell me what the paid steps cost before you do the rest. No contact
details until I pick names. Do not contact anyone.

Replace every <PLACEHOLDER> with your own detail. Everything else can stay as written.

What you need first

  • The company names, with domains, and their GitHub organisation handles if you know them
  • What the map is for: sourcing from the team, or research before a pitch
  • A Hyreflow workspace. Reading GitHub is free, credits are for the cross-check and contact details

Tools it can reach for

The agent picks per step from what your workspace has. Nothing here is required by name.

What happens when you run it

Free steps are marked free. Anything that spends credits is marked, and the agent asks before the first paid run of any size.

  1. 1

    Find the organisation

    credits

    Give the handle if you know it. Otherwise the organisation is searched for by name on GitHub, or the company's public repositories are looked up from its domain, which is a paid lookup charged whether or not it finds any.

  2. 2

    List the repositories

    free

    Every public repository under the organisation with its main language, stars and last activity, so the map shows what the team maintains today and what it left behind.

  3. 3

    Pull the contributors per repository

    free

    Who has committed to each repository and how much, with bots removed. This is the core of the map: a person's name against the systems they work on.

  4. 4

    Read each person's public profile

    free

    Name, stated employer, location, personal site and linked accounts, including LinkedIn where the person added it, plus their own repositories and languages. People who show the organisation publicly on their profile are added where GitHub lists them.

  5. 5

    Separate staff from outsiders, mark the maintainers

    credits

    Open-source projects attract contributors who never worked at the company. Stated employer, public membership, share of commits and any published code-owners file are combined into one call per person, with the evidence shown.

  6. 6

    Cross-check against the people databases

    credits

    A company-scoped search on engineering titles shows how many engineers the databases list against how many appear on GitHub. The gap is the part of the team the map cannot see.

  7. 7

    Get contact details only for the names you pick

    credits

    LinkedIn profile first, recovered by search where the GitHub profile does not link one, then a personal email from providers tried in a set order that stops at the first hit. Addresses at the employer's domain are discarded.

What a run costs

Credits are spent per candidate the play actually works, and a lookup that finds nothing usually costs nothing. The two figures are the run where the first provider answers and the run where every lookup walks its full chain.

candidatesif the first provider answersif every lookup walks the chain
25$3.232 credits$10100 credits
100$13130 credits$40400 credits
500$63630 credits$1981980 credits
1,000$1251250 credits$3953950 credits

Free before anything is charged

  • List the repositories
  • Pull the contributors per repository
  • Read each person's public profile

What moves the number

  • The channel. This play buys personal email, because these are candidates, and a work inbox is the wrong place to approach one. A personal address costs more to find than a work one.
  • Coverage on people search and personal email. The chain stops at the first provider that answers, and only that provider bills.
  • How many candidates survive the free filters. Everything dropped before the paid steps costs nothing.
  • The scoring and drafting steps run on the metered agent, charged on what they read and write rather than per candidate, so they sit outside this table.
  • Providers you connect with your own key. Those calls bill your account, not your credits.

An estimate, not a quote, priced at the volume credit rate. Your agent sizes the run against your own workspace and tells you what it will cost before it spends anything.

An org chart written in commits

A people database tells you that someone is a Senior Software Engineer at acme. It does not tell you whether they work on the payments service or the marketing site, whether they write Go or TypeScript, or whether they are the person everyone else's changes wait on.

For companies that build in the open, GitHub does. The organisation lists its repositories. Each repository lists who commits to it and how much. Each profile shows what else that person builds. Put together, that is a map of who builds what: the closest thing to an engineering org chart that exists in public, and it is free to read.

Sourcing engineers on proof of work starts from a job spec and searches all of GitHub by language and location. This play starts from the other end: one named company, and everything its public footprint says about the team inside it.

What you get back

Two tables. By repository: language, activity, contributors ranked by commits, and the maintainers. By person: name, GitHub profile, whether they look like staff or an outside contributor and why, the repositories and languages they work in, and LinkedIn where they linked it. Plus one line per company comparing the engineers visible on GitHub with the number the people databases list.

Variations worth knowing

Before a pitch. Skip contact details. Knowing that a prospect runs a small platform team looking after dozens of services is a better opening than any hiring signal, and it belongs in the account brief.

Before a raid. Run it on the firms you source from by name, with your off-limits list applied first. You approach the maintainer of the system your client needs rebuilt, not a title.

Several companies, one stack. Mapped side by side, organisations show where a language or framework is concentrated in your market and who the recognised maintainers are.

Where this goes wrong

Reading the map as the team. Membership of an organisation is hidden unless the person chooses to show it, and private repositories are invisible. What you see is the minimum, never the headcount.

Counting drive-by contributors as staff. One fixed typo is not employment. Without a stated employer or a sustained share of commits, the person is an outsider until shown otherwise.

Approaching people through their commits. Lead with LinkedIn. A recruiter email to an address published for bug reports lands badly in a community that talks to itself.

Companies with nothing public. Plenty of strong engineering teams have an empty organisation. A thin map there says nothing about the team and everything about the company's policy on open source.

Questions

How complete is the map?

It is a floor. GitHub shows people who committed to public repositories and people who chose to display their membership of the organisation. Membership is hidden unless the person makes it public, most company code is private, and whole disciplines such as infrastructure and internal tooling rarely touch a public repository. A large engineering team can show a small part of itself. The cross-check step puts a number on that gap so nobody mistakes the map for a headcount.

Is everyone who contributed an employee?

No, and this is the mistake to avoid. A popular open-source project has contributors all over the world who have never worked for the company behind it. The play treats a stated employer, public membership and a sustained share of commits as evidence of staff, and marks everyone else as an outside contributor. Outside contributors are still worth knowing: they understand the codebase and they are not bound to the company.

Which parts cost credits?

Reading GitHub is free: repositories, contributors, profiles and files. Credits go on the optional domain lookup, the step that assembles the map, the database cross-check and contact details, and the agent quotes those before it runs them. For research before a pitch, skip the cross-check and the contact details.

Can I approach people on the email in their commits?

Rarely, and never first. An address in a commit was published for a technical reason, not for recruiters. The play discards employer-domain and no-reply addresses, leads with LinkedIn, and treats a personal address found this way as a last resort, especially for anyone covered by GDPR.

Does this work for companies that do not do open source?

Poorly, and the play says so early. If the organisation has a handful of repositories and few contributors, the map stays thin however long it runs. For those companies a company-scoped people search on engineering titles is the better tool, and the agent suggests it instead of padding a map.