I automated my job (and it made me a better leader)

Leadership is an integration problem

Senior leadership is rarely difficult because of a discrete task. It is difficult because the role's obligations are spread across a dozen disconnected tools, and the person in the role is the only system that tracks them all. A comment in one thread, a decision in another, an action item added to a document you have never seen, an announcement in a channel nobody reads—until it surfaces weeks later as a casually dropped question in a meeting.

At GitHub, my team once nearly missed a performance review deadline announced in a channel no one was monitoring. A team member searched Slack for ten minutes without finding the date; another eventually located it in an unrelated channel. I ended up taking public responsibility for the miss. That was the pattern before I changed how I work.

The cost was not just missed deadlines; it was attention. I spent so much energy on context-switching that little remained for the thinking, connecting, and creating my role requires—the portion of the job I actually enjoy. The GitHub Copilot app changed that. It is a standalone desktop application for macOS, Windows, and Linux designed around working with agents. You run parallel sessions, each with live canvases showing work in real time. But the most useful feature, as it turned out, was its automations.

Standing briefs instead of ad hoc asks

Automations are scheduled prompts that run against real work context—calendar, email, messages, repositories—through MCP servers and integrations. Unlike an open-ended chat conversation, these agents carry a standing brief. You specify what they should care about, how they should think about it, and when they should run. They execute daily without any memory on your part. The output is targeted: what actually needs attention, rather than everything happening across your tools.

I did not start out trying to build dozens of them. My first setup began with a simple ask: scan all work surfaces and suggest automations that would be useful. The suggestion list came back with about six candidates, all rough drafts. Refining them was the point. You iterate, clarify the voice, and teach each one how you reason.

The automation categories that stick

My current setup has about 40 automations total. The most useful fall into a few categories.

Daily readiness

Before I open anything, my Meeting Prep automation has already pulled calendar context and formatted it for one-on-ones, large group syncs, and external calls differently. Pre-Meeting Access Check confirms I have permissions on shared docs before the meeting starts. Daily Triage Digest sweeps GitHub, email, and messages for anything needing attention. Mornings no longer mean opening a dozen tabs and hoping for the best—just reading a few summaries.

Staying current

For someone responsible for developer relations, being surprised by company launches is disqualifying. Ship Decoder finds everything shipped in the last 24 hours and translates technical release notes into plain language. Launch Radar runs weekly to surface upcoming releases touching my scope at the planning stage, not when they hit. Together these two save roughly an hour a day of manual channel scanning.

Automatic career records

This category surprised me. By default, I check completed work off and move on without recording impact. When performance reviews arrive, I empty my memory into a blank page and come up short. Daily Wins Recap runs every evening and writes down the actual accomplishments as they happen. It is a running record with facts to counter imposter syndrome on heavy days, converting an anxious blank screen into a list of substantiated contributions.

Scaffolding for trust

I draw a hard line here. The automations do not write my kudos or make personal connection happen. What they do was best demonstrated by Commitments and Follow-Up Tracker: its purpose is parsing my own messages for promises I made and flagging those unfulfilled. When I say “I will look into this” and forget, that becomes a trust problem. The automation makes sure my working memory cannot silently drop a promise to a human being. The connection work itself, the noticing and recognition, is still mine. By clearing the operational noise, the system enables me to be genuinely present in one-on-ones instead of present physically and gone mentally.

Logistics cleanup

The maintaining work that consumes a week if unchecked also falls to agents: Dependabot PR Triage merges safe dependency updates daily, Stale Work Finder surfaces forgotten pull requests, quiet issues, and gathering dust branches, and Travel Logistics Tracker collapses conference threads into a single brief. Those eliminate an entire class of low-level administrative drag.

A typical automation in practice

Prompts run shorter than people expect. My **Stale Work Finder** definition is straightforward:

Find all my stale work across GitHub using the gh CLI. Things that are falling through the cracks.

Check for:

- PRs I opened that haven't received a review in 7+ days
- PRs I'm assigned to review that I haven't reviewed yet (older than 3 days)
- Issues assigned to me that have had no activity in 14+ days
- Draft PRs I own that have been drafts for 2+ weeks
- For each item show: repo, title, link, how long it's been stale, and who's involved.

Format as:

  1. 🔴 Embarrassingly stale (3+ weeks)
  2. 🟡 Getting dusty (1-3 weeks)
  3. 🟢 Just needs a nudge (under a week)

The instruction defines scope and intent. The agent interprets it and executes on schedule—in this case, every Monday morning. Results are consistent and occasionally humbling. But the information was already known or knowable; the automation mainly makes sure it lands in front of you.

Why it scales to neurodivergence

To be direct about the why: automations are an accessibility tool for me. AuDHD supplies excellent pattern recognition and, on bad days, unreliable executive function and working memory. The inconsistency itself is the hardest element to explain. Some days I can track 17 threads successfully, others I forget a meeting in ten minutes. My team deserves consistent leadership independent of what my brain is doing any given Tuesday.

These agents narrow that gap. Institutional memory is external, in the scheduled outputs, rather than inside what is occasionally an unavailable working memory. The team gets reliably the same quality of attention because the scaffolding is stable even when cognition is not.

Starting points that work

The sensible way to build this is to avoid automating everything at once, no matter how convincing the concept seems. Pick the single point of highest friction. Mine was meeting preparation: I walked into every meeting cold because preparing required coordinated retrieval from four different applications. One automation eliminated that bottleneck completely.

Once relief registers from removing that first pain, only then add more. Refining drafts, teach your distinctive standard for "good," then let the agent run. Consolidation is possible with 40 total, but specificity has value in a clearly segmented automation footprint.

The useful approach for someone starting is plain: open the GitHub Copilot app, ask it to audit your surfaces, and let it point out where the operational drops happen in your work.

Start with one responsible prompt per pain. The rest follows.

Beyond the code

There’s a shift happening in how people talk about AI at work. The early narrative was all about generation — asking for a deliverable and getting one. In practice, particularly for those in leadership or neurodivergent professionals, the real payoff is different: automating the invisible labor that consumes attention without ever appearing in a performance review. The context-switching, the meta-work, the systems that some navigate effortlessly while others burn out managing them.

Automation won’t fix a broken process or an unreasonable workload. But reclaiming that headspace is meaningful. It can give you the room to focus on the job you were actually hired to do.

The same tools handle more conventional developer tasks — dependency updates, issue triage, security sweeps across repositories. Those workflows are solid. But the underappreciated use case is handling the parts of the role that never make it into the job description.

Build your own automations in the GitHub Copilot app.