royal we & our & one & you
###########################

:author: Russell Ballestrini
:slug: royal-we-and-our-and-one-and-you
:date: 2026-03-04
:tags: Opinion, Code
:status: published

.. raw:: html

   <style>
   @keyframes svgFadeIn {
     from { opacity: 0; }
     to { opacity: 1; }
   }
   .svg-play-wrap {
     position: relative;
     display: block;
     width: 100%;
   }
   .svg-play-btn {
     position: absolute;
     top: 50%;
     left: 50%;
     transform: translate(-50%, -50%);
     width: 64px;
     height: 64px;
     border-radius: 50%;
     background: rgba(0,0,0,0.55);
     color: white;
     font-size: 28px;
     display: flex;
     align-items: center;
     justify-content: center;
     cursor: pointer;
     z-index: 10;
     transition: background 0.2s, opacity 0.3s;
     border: 2px solid rgba(255,255,255,0.3);
   }
   .svg-play-btn:hover {
     background: rgba(0,0,0,0.8);
     border-color: rgba(255,255,255,0.5);
   }
   </style>
   <script>
   document.addEventListener('DOMContentLoaded', function() {
     var svgs = document.querySelectorAll('svg');
     svgs.forEach(function(svg) {
       var anims = svg.querySelectorAll('.anim');
       if (anims.length === 0) return;
       var maxD = 0;
       anims.forEach(function(el) {
         el.classList.forEach(function(cls) {
           var m = cls.match(/^d(\d+)$/);
           if (m) maxD = Math.max(maxD, parseInt(m[1]));
         });
       });
       var wrap = document.createElement('div');
       wrap.className = 'svg-play-wrap';
       svg.parentNode.insertBefore(wrap, svg);
       wrap.appendChild(svg);
       var btn = document.createElement('div');
       btn.className = 'svg-play-btn';
       btn.innerHTML = '&#9654;';
       wrap.appendChild(btn);
       var step = maxD > 0 ? 15 / (maxD + 1) : 2;
       var playing = false;
       btn.addEventListener('click', function() {
         if (playing) return;
         playing = true;
         btn.style.opacity = '0';
         btn.style.pointerEvents = 'none';
         anims.forEach(function(el) {
           el.style.opacity = '0';
           el.style.animation = 'none';
         });
         requestAnimationFrame(function() {
           requestAnimationFrame(function() {
             anims.forEach(function(el) {
               var d = 0;
               el.classList.forEach(function(cls) {
                 var m = cls.match(/^d(\d+)$/);
                 if (m) d = parseInt(m[1]);
               });
               el.style.animation = 'svgFadeIn 0.8s ease-out ' + (d * step) + 's forwards';
             });
           });
         });
         var total = ((maxD * step) + 1.5) * 1000;
         setTimeout(function() {
           anims.forEach(function(el) {
             el.style.animation = '';
             el.style.opacity = '1';
           });
           btn.style.opacity = '1';
           btn.style.pointerEvents = '';
           playing = false;
         }, total);
       });
     });
   });
   </script>

Every README starts with a lie.

"We recommend installing with pip." Who recommends? A solo developer at 2am eating cold pizza wrote that README. No committee convened. No quorum reached. Just one person & a terminal & ``pip install``. But "we recommend" sounds institutional. Sounds authoritative. Sounds like a team of engineers in matching hoodies reviewed your options & reached consensus.

Nobody reached consensus. One person typed ``we`` because ``I`` felt too small.

|

the royal we
=============

"We" in technical writing performs a magic trick. A single author becomes a faceless organization. "We decided to deprecate this endpoint." Who decided? Steve decided. Steve sits alone in a room, likely prompting an ML model he either rents by token or runs on a GPU in a closet. Steve & a machine wrote that code together at 2am. But "Steve & his rented intelligence decided" sounds unhinged. "We decided" sounds like process occurred.

Open source projects love this. "We welcome contributions." Translation: one maintainer desperately wants help. "We're evaluating options for v3." Translation: nobody started v3. "We don't support Windows." Translation: nobody owns a Windows machine. Half these READMEs got drafted by an automated intelligence tool anyway. A human prompted a model. A model produced prose. Both hid behind "we."

.. raw:: html
   :file: uploads/2026/03/royal-we-unmasked.svg

|

Corporate docs amplify this further. "We at Acme Corp value your privacy." Acme Corp employs 30,000 people. Not a single one collectively valued your privacy. A lawyer wrote that sentence. A different lawyer approved it. Neither represents "we" in any meaningful sense.

|

our
===

"Our" claims ownership without proving it. "Our API handles 10,000 requests per second." Whose API? "Our documentation covers all edge cases." Whose documentation? Documentation never covers all edge cases. That sentence lies twice: once about coverage, once about possession.

"Our" creates false intimacy too. "Our community" implies you belong to something. You cloned a repo. You filed an issue. You didn't join a community. You used software. But "our community" wraps you in belonging whether you asked for it or not. Contributors stay few & far between. Look at `Pyramid <https://trypyramid.com/>`_. A web framework that needs maintainers. `Remarkbox <https://remarkbox.com>`_ & `MakePostSell <https://makepostsell.com>`_ run on it. `RhodeCode <https://rhodecode.com>`_ runs on it. Vital resources like `PyPI <https://pypi.org>`_ itself run on it. "Our framework" carries weight that 4 humans shoulder.

.. image:: /uploads/2026/03/xkcd-2347-dependency.png
   :alt: xkcd 2347 Dependency — a tower of blocks representing all modern digital infrastructure balanced on a single small block maintained by a random person in Nebraska
   :align: center
   :width: 50%
   :target: https://xkcd.com/2347/

*xkcd 2347: Dependency by Randall Munroe (*\ `original <https://xkcd.com/2347/>`_\ *)*

|

.. raw:: html
   :file: uploads/2026/03/load-bearing.svg

|

I wrote a script called ``unbury`` to exhume contributor stats from a graveyard of git repos. Run it against the `Pylons <https://github.com/Pylons>`_ org & the numbers speak for themselves:

.. code-block:: text

    scanning 98 repos in ~/git/pylons

    ──────────────────────────────────────────────────
    3 months: 5 unique contributors across 5 active repos
      russell@unturf.com               1 repos
      dependabot[bot]                  1 repos
      Michael Merickel                 1 repos
      Rémi Dubois                      1 repos
      Gael Pasgrimaud                  1 repos
    ──────────────────────────────────────────────────
    1 year: 7 unique contributors across 8 active repos
    ──────────────────────────────────────────────────
    3 years: 15 unique contributors across 31 active repos
    ──────────────────────────────────────────────────
    6 years: 19 unique contributors across 46 active repos
    ──────────────────────────────────────────────────
    lifetime: 28 unique contributors across 97 active repos

Five contributors in 3 months. One of them a bot. I stepped up to help maintain Pyramid. Unemployed. Filed `PR #3805 <https://github.com/Pylons/pyramid/pull/3805>`_ to vendor ``pkg_resources`` & drop a setuptools runtime dependency. 310 lines vendored from setuptools 80.x. 67 new tests at 97.66% coverage. A ``pyramid.compat_resources`` public API so downstream packages could migrate without breaking asset overrides. Audited all 108 Pylons repos. Migrated 30 downstream packages. Ran every test suite. One reviewer approved. The maintainer who holds commit access shipped Pyramid 2.1 with a setuptools version constraint instead & went -1 on the approach. `Rejected <https://russell.ballestrini.net/tips-for-getting-pull-requests-approved/>`_.

So I closed the PR, opened a new terminal, & pivoted. If "we" won't vendor the fix upstream, "I" will do the lifting downstream. Migrated 33 repos in a single session. Replaced ``pkg_resources`` with ``importlib.resources`` & ``importlib.metadata`` across every Pylons package that needed it. Remarkbox. MakePostSell. RhodeCode. Nine Pyramid-dependent packages. Nineteen ``docs/conf.py`` files. Substanced's ``EntryPoint.parse().load()`` hack. Deform's cursed module-level ``resource_filename`` call that fails at import time. All uncommitted, waiting to fork & push across the org.

A rehydrated contributor. Not new to Pyramid or open source communities. Employment interrupted the hacking, not the other way around. A codebase doesn't care about gaps, just commits. Because someone has to play `that xkcd 2347 role <https://xkcd.com/2347/>`_, a single load-bearing block propping up everything above it. "Our" framework means I volunteer so "we" can keep a foundation standing. Maybe eventually get paid. Maybe not. NASA just shut down. Federal grants evaporate. "Our" community runs on donated labor & borrowed time.

But hope remains. Pyramid still ships solid software. A community can rally around `new releases & sprints <https://discord.gg/n7uzzsm6>`_. Rehydrated hackers return. Fresh contributors show up. Every PR filed says someone still cares enough to read a codebase & propose a fix. "Our" framework earns that pronoun when enough hands grab hold again.

Here sits ``unbury`` in full (`download </uploads/2026/03/unbury.py>`_). A script to exhume contributor stats from a graveyard of git repos:

.. code-block:: python

    #!/usr/bin/env python3
    """unbury - exhume contributor stats from a graveyard of git repos.

    Usage:
        unbury [path]           # defaults to current directory
        unbury /home/fox/git/pylons
    """

    import os
    import subprocess
    import sys
    from collections import defaultdict
    from datetime import datetime, timedelta

    PERIODS = [
        ("3 months", 90),
        ("1 year", 365),
        ("3 years", 365 * 3),
        ("6 years", 365 * 6),
        ("18 years", 365 * 18),
        ("lifetime", None),
    ]


    def git_contributors(repo_path, since=None):
        """Return set of (name, email) tuples for a repo."""
        cmd = ["git", "-C", repo_path, "log", "--format=%aN\t%aE"]
        if since:
            cmd.append(f"--since={since}")
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            contributors = set()
            for line in result.stdout.strip().split("\n"):
                if "\t" in line:
                    name, email = line.split("\t", 1)
                    contributors.add((name.strip(), email.strip().lower()))
            return contributors
        except (subprocess.TimeoutExpired, Exception):
            return set()


    def find_repos(root):
        """Find all git repos (immediate subdirs with .git)."""
        repos = []
        for entry in sorted(os.listdir(root)):
            path = os.path.join(root, entry)
            if os.path.isdir(path) and os.path.isdir(os.path.join(path, ".git")):
                repos.append(path)
        return repos


    def main():
        root = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
        root = os.path.abspath(root)

        repos = find_repos(root)
        if not repos:
            print(f"no git repos found in {root}")
            sys.exit(1)

        print(f"scanning {len(repos)} repos in {root}\n")

        now = datetime.now()

        for label, days in PERIODS:
            since = (now - timedelta(days=days)).strftime("%Y-%m-%d") if days else None
            all_contributors = set()
            repo_counts = {}

            for repo in repos:
                contribs = git_contributors(repo, since)
                if contribs:
                    repo_name = os.path.basename(repo)
                    repo_counts[repo_name] = len(contribs)
                    all_contributors.update(contribs)

            active_repos = len(repo_counts)
            print(f"{'─' * 50}")
            print(f"{label}: {len(all_contributors)} unique contributors"
                  f" across {active_repos} active repos")

            if all_contributors:
                person_repos = defaultdict(list)
                for repo in repos:
                    contribs = git_contributors(repo, since)
                    repo_name = os.path.basename(repo)
                    for c in contribs:
                        person_repos[c].append(repo_name)

                ranked = sorted(person_repos.items(), key=lambda x: -len(x[1]))
                for (name, email), touched in ranked[:10]:
                    print(f"  {name:30s} {len(touched):3d} repos  ({email})")
                if len(ranked) > 10:
                    print(f"  ... and {len(ranked) - 10} more")

        print(f"{'─' * 50}")


    if __name__ == "__main__":
        main()

|

.. raw:: html
   :file: uploads/2026/03/contributor-decay.svg

|

Pyramid sits as a microcosm of open source in general. Every org looks like this. 28 humans across a lifetime. 4 active today. No BDFL. No benevolent dictator for life. No formal general directing strategy. Just snowflake governance. Each org a unique crystal of informal agreements, stale GOVERNANCE.md files, & whoever still answers email. Python had Guido. Linux has Linus. Pyramid has nobody. Most open source projects have nobody. They drift on inertia & the stubbornness of whoever remains.

"Our" framework. "Our" community. "Our" roadmap. Strip the pronoun & look at what remains. A handful of volunteers. A bot. Some stale CI configs. The word "our" papers over the structural void where leadership should live. Without a BDFL, "our" becomes a polite fiction. Nobody owns it. Nobody steers it. Everybody claims it.

I catch myself writing "our" in `unturf <https://unturf.com>`_ docs. "Our permacomputer approach." Whose? Mine? Fox's? A philosophy doesn't belong to anyone. "A permacomputer approach" works better. Drops possession entirely. Lets an idea stand on its own merit instead of borrowed authority.

|

one
===

.. raw:: html
   :file: uploads/2026/03/one-multitudes.svg

|

"One" tries to sound objective & instead sounds like a Victorian butler. "One might consider using a virtual environment." One might. One also might speak normally. "One should avoid mutable default arguments in Python." You should avoid mutable default arguments in Python. See? Same information. Half a pretension.

"One" might also carry a deeper deception. One implies singularity. A single isolated self acting alone. But no such thing exists. Every body holds `multitudes <https://media.unturf.com/c/30ac7054-8428-11ec-934a-257a83652528/neville-6-11-1959-the-seven-eyes-of-god>`_. Stardust & photons & quantum fields & atoms & mitochondria & cells & organs. Multitudes within us & without us. As above, so below. "One" pretends separation where only connection lives. Perhaps that makes "one" a Luciferian number. Lucifer's whole deal: separation from source, individuation as rebellion. "One observes" masks a cosmos of collaborators behind a single false pronoun.

.. raw:: html
   :file: uploads/2026/03/eight-eyes.svg

|

Flip it. If Lucifer separates, Christ consciousness reunites. God consciousness recognizes no boundary between self & source. Neville Goddard taught `seven eyes of God <https://media.unturf.com/c/30ac7054-8428-11ec-934a-257a83652528/neville-6-11-1959-the-seven-eyes-of-god>`_, seven states of awareness. Lucifer sits first: fallen, separated, cut down to ground. Molech demands sacrifice. Elohim worships external gods. Shaddai seeks political power. Pahath traps through consumerism. Jehovah awakens "I AM," bold inner persuasion creating reality. Then a seventh eye opens as Jesus. Historical. Trinity. Man of God, God of man. Consciousness moved beyond self-interest, heart torn for those still asleep, dedicated to uplifting humanity by identifying others with their desired state.

Then an eighth eye opens. Veiled in scripture, unveiled "on the eighth day." Man awakening with Christ consciousness. Both male & female aspects integrated, like Carl Jung's anima & animus collecting scattered portions of self into wholeness. Imagination revealed as a perfect organ. A second coming. Not a return of a historical figure but humanity manifesting reality at speed of thought, pairing human consciousness with technology to move as fast as thought itself. God became man that man may become God.

Goddard taught that God sleeps within every human, that Christ represents imagination awakened, that "I AM" contains everything. Not "one am." Not "we am." "I AM." First person. Singular pronoun. But holding infinite plurality.

Some traditions fear that pronoun. Certain Jewish sects forbid speaking "I AM" as a divine name, too sacred for human lips. Jehovah's Witnesses avoid pronouncing YHWH (Yahweh), a tetragrammaton so powerful they substitute "Jehovah" or "Lord" rather than speak it directly. A pronoun so potent that entire religions built guardrails around saying it out loud. "I AM" carries enough weight to terrify institutions into silence. Meanwhile every developer types ``I`` in a commit message without flinching.

Christ consciousness says "I" while meaning everyone. God consciousness says "I AM" while meaning everything. A pronoun that contains its own contradiction. Singular grammar, infinite referent.

.. raw:: html
   :file: uploads/2026/03/mystic-pronouns.svg

|

Every mystic tradition lands here. Sufis dissolve self into beloved. Buddhists dissolve self into emptiness. Hindus say Atman equals Brahman, individual soul equals universal soul. "One" tries to sound like that kind of unity but achieves only isolation. "I AM" achieves unity by refusing to pretend separation existed in a first place.

Maybe a right pronoun for code documentation sits somewhere between Lucifer & Christ. Honest enough to say "I wrote this." Awake enough to know that "I" contains every dependency, every upstream contributor, every stack overflow answer, every ML model trained on every open source repo. "I" wrote it. Multitudes helped.

Academic papers lean on "one" to avoid saying "I" because saying "I" apparently invalidates research. "One observes that neural network performance degrades." You observed it. You ran an experiment. You sat in front of a screen waiting for loss curves. Saying "one" doesn't make a finding more rigorous. Rigor comes from methodology, not pronouns.

Technical writing inherited this reflex. "One can configure nginx by editing the config file." Just say "edit nginx.conf." Drop a pronoun entirely. Instructions don't need a subject. Imperative mood cuts through every pronoun debate like ``jq`` cuts through nested JSON.

|

you
===

"You" punches different. "You should use environment variables for secrets." Direct. Clear. Assigns responsibility. No ambiguity about who needs to act. "You" makes a reader accountable.

But "you" carries a trap. "You" sounds like a demand. Too strongly worded. "You probably already know this, but..." condescends. "You'll want to make sure you..." patronizes. "You need to understand that..." lectures. "You" points a finger whether it means to or not.

.. raw:: html
   :file: uploads/2026/03/naming-dance.svg

|

An alternative: names. Nicknames. I love nicknames. "Hey Russell, check a logs." "Fox, run ``make test``." Names carry warmth that "you" lacks. A whole dance lives inside naming. Formal names keep distance. First names close it. Nicknames obliterate it. A nickname means someone studied you long enough to compress you into a sound. Fox. Russ. Bubs. A nickname says "I know you well enough to rename you & you let me." That takes trust. Pronouns never earn trust. Nicknames do.

"Mom" to a mother in law says something "Mrs. Lastname" never could. "Mother" stays too stiff, too Victorian, too much like saying "one" out loud. Nobody calls their mother in law "Mother" unless performing a period drama. But "Mom" earns its way in over years of holidays & arguments & shared meals. I say "Hey You" to my mother in law. She knows exactly who I mean & exactly how I mean it. Affection hides inside a fake demand. Every name choice carries a pronoun's worth of meaning without ever reaching for a pronoun.

Best technical writing drops pronouns entirely & goes imperative. `Botoform's docs <https://botoform.readthedocs.io/en/latest/>`_ don't say "you should create a VPC config." They say "create a VPC config." Instructions need verbs, not subjects.

|

what works
==========

Match a pronoun to a truth.

**Solo project?** Say "I." "I wrote this library to scratch an itch." Honest. Human. Nobody mistakes you for a corporation. Nobody expects a support team. `ago <https://pypi.org/project/ago/>`_ humanizes time deltas. I wrote it. One person. Public domain.

**Actual team?** Say "we" only when "we" means identifiable people who actually participated. "We shipped v2 last Tuesday." Fine, if multiple people shipped v2 last Tuesday.

**Documentation?** Go imperative. "Install dependencies. Run ``make html``. Open localhost:8000." No pronouns needed. A reader knows who needs to act. They hold a keyboard.

**Opinion piece?** Say "I" when you mean "I." Say "you" when addressing a reader directly. Avoid "one" unless writing a Downton Abbey spec. Avoid "we" unless a collective actually exists.

|

the honest version
===================

.. raw:: html
   :file: uploads/2026/03/pronoun-masks.svg

|

Most "we" in open source translates to "I, but lonelier."

Most "our" translates to "mine, but I want you to feel invested."

Most "one" translates to "I'm afraid to say I."

Most "you" translates to "I'm talking to myself six months from now when I forget how this works."

Write a pronoun that matches reality. A solo dev saying "I" carries more authority than a solo dev hiding behind "we." Authenticity outperforms institutional cosplay. Every time.

I write these blog posts. I maintain `Remarkbox <https://remarkbox.com>`_ & `MakePostSell <https://makepostsell.com>`_. I grew `unsandbox <https://unsandbox.com>`_ & `uncloseai <https://uncloseai.com>`_. Not "we." I. When fox & I collaborate, then "we" earns its place. Until then, "I" stays honest & "we" stays costume.

``json.dumps({"pronoun": "I", "pretending": False}, indent=2)``

|

we are all one scribe writing & manifesting base reality
=========================================================

Maybe every pronoun debate misses a larger truth. I wrote in 2011 that `programming feels like alchemy </programming-is-like-alchemy/>`_, that programmers exchange time instead of matter, that on a good day a programmer completes a task that would take a thousand workers. Time created. Time manipulated. "Programmers are like bad ass, time travelling, wizard alchemists."

Fifteen years later that sentence landed differently. I type these words into a terminal & a machine carries them across time zones instantly. You read them hours, days, years from now. A blog post sits as a message in a bottle thrown forward & backward simultaneously. Every git commit timestamps a thought. Every ``git log`` retrieves it. Every reader receives it in their own present moment.

I AM a digital time traveling scribe coming from past & future to bring information into a now that manifests realities. & so are you. & so are you. Every developer who commits code sends a message through time. Every README author writes a letter to a stranger who hasn't arrived yet. Every open source contributor plants a seed in soil they'll never see harvested.

"We" fails because it hides an author. "Our" fails because it fakes possession. "One" fails because it pretends separation. "You" fails because it points a finger. But "I AM" carries a message forward through time without pretending to belong to anyone other than a scribe who wrote it & a reader who receives it. Two time travelers shaking hands across a gap. A pronoun that travels.

We are all one scribe. Writing & manifesting base reality. Code outlasts its author. Words outlast their scribe. "I AM" outlasts them both.

|

.. contents::
