• A weekly-reporter that only surfaces genuinely new accomplishments — and outputs “No new accomplishments this week” when there aren’t any

• A comm-coach-auditor that tracks whether your communication flaws are actually improving, recurring, or corrected - instead of rediscovering the same issue every session.

• A first-run diagnosis mode that lets the comm-coach generate your SKILL.md from your own transcripts, so the agent tells you what to practice rather than you guessing.

• A reusable pattern for making any accumulating agent trustworthy over time

What you need

Both agents from the previous articles already set up and running:

• weekly-reporter skill: ~/.claude/skills/weekly-reporter/SKILL.md — from The last status report you’ll write by hand

• comm-coach-auditor command: ~/.claude/commands/comm-coach-auditor.md — from How to command meetings better than 99% of tech managers

Two new Notion pages (the agents create these on first run if they don’t exist):

• Accomplishments Log — the weekly-reporter’s exclusion filter

• Communication Capabilities Journal — the comm-coach’s improvement diary (you may already have this if you’ve been running the auditor)

An annoying issue: agents without memory repeat themselves

By definition, agents without context have a significant flaw - they’re stateless. Every run starts from scratch with no knowledge of what was found last time.

For the weekly-reporter, this means the same accomplishment surfaces across consecutive runs - just worded differently. After I built the agent, it correctly reported in its first run:

“Shipped the core content asset for the weekly-reporter launch. Wrote and iterated a full Substack draft built around a personal management story — 2 hours reclaimed, how they were spent.”

Accurate and useful, so far so good 🙂

The following week, the same PR and the same Notion page were still the most recent artifacts in the window. So the agent surfaced them again as: “Completed and finalized the Substack article on status reporting automation.”

Uhhhh.

Same work, different sentence? Completely useless to anyone reading the report - and a trust issue, because I started to wonder what else is being recycled…

For the comm-coach-auditor, the problem is the different but equally frustrating. The agent identified a pattern in my communication: stating conclusions without anchoring them in what the listener already knows. It first surfaced this precisely:

“Setting the context (Client Infrastructure Review): ‘At current scale we can handle this migration in two phases without impact to availability.’ — the client’s actual concern was whether the first phase could land before their Q3 deployment freeze, not availability in general. No context was established for what constraint the recommendation was responding to.”

Again, very useful because of its specificity. It was actionable, so I worked on it.

Then the next session flagged the same pattern again as a fresh discovery. And the session after. The agent was rediscovering it from scratch each time, with no memory that it had already been named, worked on, and partially corrected.

Fortunately, the fix is the same in both cases: a persistent log the agent reads before it reasons, and writes to after it finishes.

The concept: closing the Feedback Loop

Three steps:

1. Dump all findings into a log — every accomplishment the weekly-reporter surfaces, every flaw the comm-coach flags

2. Read the log before reasoning — use it as an exclusion filter (weekly-reporter) or a progress tracker (comm-coach)

3. Output only the increment — what is genuinely new, what has been corrected, what has regressed

For the weekly-reporter, “new” means: not already in the Accomplishments Log. For the comm-coach, “new” means: a flaw not previously flagged, or a regression of something marked corrected.

This makes both agents dramatically more useful to read. You don’t have to filter the noise anymore - you can actually act on pure signal.

The modified weekly-reporter

Two additions to the existing skill file: a LOG config variable pointing at a Notion page, and two new steps - one that reads the log before compilation, one that updates it after.

## Additional workflow steps (insert into existing weekly-reporter)

## Configuration

[...]
<!-- ADD THIS -->
ACCOMPLISHMENTS_LOG: Accomplishments Log   # exact Notion page title

<!--
FIRST-RUN INITIALIZATION
On first installation, run the agent repeatedly with increasing LOOKBACK_DAYS
(7, 14, 21, 28) until it outputs "No new accomplishments from the last week."
This builds the exclusion filter from your backlog so future runs only surface
genuinely new work.
-->

## Workflow

[...]

<!-- ADD THIS -->
[**Prerequisite**] Load the Accomplishments Log:
   - Search Notion for a page titled ACCOMPLISHMENTS_LOG.
   - If it does not exist, create it — this is the first run.
   - Read all existing entries. Each entry is a previously reported accomplishment.
   - Any item in the log is EXCLUDED from this run — even if it appears in the
     source data. Do not include it. Do not rephrase it.

<!-- ADD THIS -->
5. Update the Accomplishments Log:
   - Append each new accomplishment from this run to the log page in Notion.
   - Format: [YYYY-MM-DD] — [accomplishment, one sentence]

The modified comm-coach-auditor

The comm-coach already has a Communication Capabilities Journal. The modification extends it: the agent now reads the journal before scoring, tracks first-flag and last-occurrence dates, and reports corrections when a flaw has been absent for two consecutive sessions.

## Additional workflow steps (insert into existing comm-coach-auditor)

2b. Load the Communication Capabilities Journal before scoring:
   - Fetch the journal page from Notion.
   - Extract all previously flagged weak points with:
     - first_flagged: date the pattern was first identified
     - last_occurrence: most recent session it appeared
     - status: active | corrected | regression
   - This list is the context for step 5 — use it to classify every finding.

5b. Classify each finding before logging:

   NEW: this pattern has not appeared in the journal before.
        Log it with today as first_flagged. Status: active.

   RECURRING: this pattern appeared in the journal and has occurred again.
              Update last_occurrence. Increment recurrence count.
              Do NOT present it as a new discovery.

   CORRECTED: this pattern appeared in the journal but has NOT occurred in any
              transcript reviewed in the last two sessions. Output:
              "You have corrected [flaw name]. Last occurrence: [date].
              Monitoring for regression."
              Update status to: corrected.

   REGRESSION: a corrected pattern has reappeared. Flag explicitly as a
               regression — not a new discovery. Update status to: regression.

<!--
DIAGNOSIS MODE — FIRST INSTALLATION
If no SKILL.md exists at SKILLS_FILE, run in diagnosis mode:
1. Review the last 5 available transcripts without a skills file.
2. Identify the top 3 recurring communication patterns across them.
3. Draft a SKILL.md based on those findings and save it to SKILLS_FILE.
4. Ask the user to review and confirm before the next scored run.

This lets the agent generate your SKILL.md from your own communication data
rather than requiring you to write it cold from scratch.
-->

On the data source

The log files live wherever your agents already read from. If you’re on Notion, the Accomplishments Log and the Communication Capabilities Journal are just Notion pages - the agents create them on first run if they don’t exist.

If you’re on Google Drive, replace the Notion fetch and update steps with read_file_content and create_file against a Google Doc. The logic is identical; only the storage layer changes. The same applies to Microsoft 365 via SharePoint - swap the Notion MCP calls for Microsoft Graph, and the pattern transfers directly.

This is the third piece in the series. The first article gave you the weekly-reporter. The second gave you the comm-coach. This one makes both of them trustworthy enough that you stop second-guessing the output — and start spending the attention you saved on the work that actually matters.

If you run into issues setting up this workflow in your workspace, shoot me an email or DM me. I’ll help you get it up and running.

I think they’re looking at the wrong thing.

The managers who should be anxious are the ones whose authority came from knowing more than their individual contributors. The solution architect who became a manager and held the technical high ground. The senior engineer promoted because they were the most capable person in the room.

That version of management is getting harder to sustain… contrary to the common narrative that “AI makes you irrelevant”, what I’m seeing is AI is lifting your team’s floor faster than you're figuring out where you stand.

The technical competence gap between managers and team members is narrowing.

But there’s another kind of manager, whose edge was never competence but was judgment and the capability to make the right calls that would materialize not for the deliverable - but for the team, the bosses, the customers.

Let me tell how how I learned that the hard way.

I mention the changing business model that I went through, and that’s a microcosm of what is happening across the industry right now - jobs being changed, leaders and individual contributors being asked to do more with AI and the top leadership not giving clear prescription on how to add value with AI, but just to “go all in”.

Here’s why I think this is a golden era for managers with the right skills.

When the technical floor rises - when your individual contributors can do in two hours what used to take two days, when status reporting writes itself, when code review is partially automated - something gets freed up.

There’s a conversation to be had about “ok, what should I be doing” and “how do I create more impact instead of just doing more work”?

I want it to start with leadership.

Here is what AI makes possible that nothing else has.

After any significant meeting, I run the transcript through an AI review. Not for merely a summary - to ask the question I’m too close to answer while I’m still in the room.

• Where was I vague?

• Where did I leave a loop open?

• Where was I reacting to the surface of what someone said instead of what they actually meant?

The first few times, it feels like light editing. You catch a sentence here, a dropped thread there. Useful, but far from transformative.

After a week, something shifts. You start seeing the same pattern appear again and again - the same tendency to give information of instead of providing the answer, that moment where you feel the slight urge to avoid the error but you yield nevertheless. At the very least the pattern starts resembling a shape - you can recognize it before it happens.

By week four, you’re making different calls in real time, because the habit is changing.

That is not something a quarterly coaching session produces and neither does reading a management book. It is the result of a feedback loop that runs after every significant conversation - on a consistent basis, without ego, without the social dynamic of admitting something embarrassing to another person.

The machine doesn’t care… it just shows you what happened.

This is what I mean by unprecedented - the ability to hone a skill that previously had no reliable feedback mechanism. And compound interest on a skill with a tight feedback loop is extraordinary.

More on my experience with the communication coach agent in the article below.

You see the same pattern in your own communication appear three weeks in a row and suddenly it’s not abstract anymore… it’s a habit you can name and act upon accordingly.

The managers who will lead in this environment aren’t the ones who figured out how to use AI to move faster. They’re the ones using it to get better at the parts of the job that don’t automate: the creativity, the conversations, the relationships. The calls that look small but determine everything downstream.

Technical competence is becoming a commodity. Judgment - the ability to know what a situation actually requires, and to have the precision to deliver it - is becoming scarce in relative terms.

Now it’s something you can train deliberately, consistently, starting this week.

That is why this is the golden age of leadership - for the first time, the most important skill in the job has a development path.

Which kind of a leader are you going to be on the other side of it?

What you’ll get from this article

An agentic skill to apply daily (or as frequently as you’d like - I set it to run every evening at 7pm after finishing my workday) to coach your abilities to correctly set the stage of a meeting, elegantly steer its flow, and conclude sessions with clarity.

By incorporating this skill into your workflow, you will be able to:

• use meeting transcripts as the critical input for the agent, so that it identifies weak spots in your communication;

• get a no-BS, direct debrief after every call, using criteria that are tracked over time;

• go into every call with one specific thing to practice, automatically scheduled for the next morning;

• get agentic feedback whether you’re actually improving or not.

What you need

A workspace where transcripts land (pick one!):

• Notion: native with Notion AI, or paste manually after any call;

• Google Workspace: Google Meet + Gemini Notes saves transcripts to Drive automatically;

• Microsoft 365: Teams meetings generate transcripts to SharePoint.

This article focuses on the integration with Notion and Claude Code, where I have both my call transcripts and the calendar integration.

Tooling:

• Claude Code (the agent runs as a /comm-coach-auditor slash command);

• Notion MCP connected to Claude Code;

• Google Calendar connected to Claude Code.

Your time:

• 20 minutes to write your skill.md file: the rubric that tells the agent what to look for. Explained in the next section.

The Skill.md file

This is the most important piece: the agent reads your transcript against this file, so what you put in it determines what it finds.

I put the following dimensions:

Clarity of recommendation. After this call, does the listener know what to do, or at minimum what to think? A call that ends without a clear takeaway is a communication failure.

Loop closure. Every question that opens in a conversation should either get answered or explicitly deferred. Open loops at the end of a call are ambiguity the listener has to carry.

Setting the context. Is the technical content anchored to decisions the listener actually faces? No clear context means working on the wrong things.

However - we can’t continue without you writing your own Skill.md! It sets the communication dimensions that depend strictly on your role and who you’re talking to. Vague criteria produce vague feedback 👎🏻

Have a look at my Skill.md and use it as a template to craft your own:

# Communication Skill Dimensions

## Clarity of recommendation
After this call, does the listener know what to do, or at minimum what to think?
A call that ends without a clear takeaway is a communication failure, regardless of how much was said.

## Loop closure
Every question that opens in a conversation should either get answered or explicitly deferred.
Track the ratio of questions raised to questions resolved. Open loops at the end of a call
are ambiguity the listener has to carry.

## Setting the context
Is technical content anchored to decisions the listener actually faces?
"The provisioning latency is within acceptable range" is not grounded.
"At current scale we're provisioning 10 VMs in under 8 minutes — which means your
product team's 30-minute window is comfortable" is.

There is no right or wrong set of communication dimensions, the important thing is to make it your own. It doesn’t have to be perfectly crafted right off the bat - I did many iterations of my Skill.md before posting it here. In the end, you also want to use the agent to uncover any communication flaws so that you’re aware of them.

The agent

Save the following as ~/.claude/commands/comm-coach-auditor.md to make it available across all your projects, or in .claude/commands/comm-coach-auditor.md to scope it to one workspace. Invoke it by typing /comm-coach-auditor in Claude Code.

# Comm Coach Auditor

> Audits today's 1:1 and technical sync transcripts against a defined skills file. Appends a structured assessment to a running Communication Capabilities Journal and schedules a private Comms Prep block in Google Calendar for the next workday. Use when you want structured, transcript-grounded feedback on how clearly you communicated — not a general impression, a scored evaluation with specific quotes. Do not use without a skills file in place, and do not use for real-time coaching or sessions where no transcript exists.

## Configuration

```
SKILLS_FILE:   ~/ai/business/skill.md             # path to your skills file
JOURNAL_TITLE: Communication Capabilities Journal # exact title of the journal page in Notion
PREP_TIME:     10:00                              # local time for the Comms Prep calendar block
PREP_DURATION: 30                                 # minutes
```

Adjust `SKILLS_FILE` to wherever you keep your skills file before running. The agent reads it in step 3 and anchors every scoring decision to it. If the file does not exist, the agent will ask before proceeding.

<!--
TEMPLATE NOTE FOR READERS — Notion + Google Calendar is the stack wired up here, but you can
swap any step for the following alternatives with minimal changes:

  TRANSCRIPT SOURCE (step 2)
  • Google Drive    — tools: mcp__claude_ai_Google_Drive__search_files,
                             mcp__claude_ai_Google_Drive__read_file_content
                     Use when: transcripts land as Google Docs via Gemini Notes after Google Meet.
                     Search for "Transcript:" or "Meeting notes:" in the filename.

  • Microsoft 365   — tools: Microsoft Graph MCP server (SharePoint, Teams messages)
                     Use when: transcripts land in SharePoint via Teams transcription.
                     Filter by today's date and meeting title prefix.

  JOURNAL (step 6)
  • Google Drive    — Create/append to a Google Doc named JOURNAL_TITLE.
                     tools: mcp__claude_ai_Google_Drive__create_file,
                            mcp__claude_ai_Google_Drive__read_file_content,
                            mcp__claude_ai_Google_Drive__download_file_content
  • Local file      — Read/append to a local markdown file (e.g. ~/ai/business/comm-journal.md).
                     tools: Read, Edit

  CALENDAR (step 7)
  • Google Calendar — wired up below. Uses mcp__claude_ai_Google_Calendar__create_event.
  • Notion          — Create a page titled "Comms Prep — [YYYY-MM-DD]" in your workspace.
                     tools: mcp__claude_ai_Notion__notion-create-pages
  • Manual          — Output the event details as plain text for the user to schedule manually.
-->

## Overview

This skill guides the agent in auditing today's meeting transcripts for communication quality. It reads each transcript against the dimensions in the skills file, identifies the top weak points with exact transcript quotes, logs the assessment to a running journal, and creates a focused practice block in the calendar for the next morning.

The output is not a general impression. It is a scored, quote-backed evaluation with a concrete drill for each identified gap.

## Workflow

1. **Identify today's meetings**: Use `mcp__claude_ai_Google_Calendar__list_events` to retrieve today's calendar events. Filter for 1:1s and technical syncs — events with 2 attendees, or titles containing "sync", "1:1", "check-in", "catchup", "debrief", or a person's name.

2. **Locate transcripts**: For each meeting identified, use `mcp__claude_ai_Notion__notion-search` to find the corresponding transcript or meeting notes page. Search for:
   * The exact meeting title
   * Common prefixes: "Transcript:", "Notes:", "Meeting notes —", participant name + today's date

   Note any meetings with no transcript found and continue. Do not stop on a missing transcript.

3. **Load the skills file**: Use the Read tool to load the file at `SKILLS_FILE`. If it does not exist, ask for its location before proceeding. Every scoring decision in step 4 must anchor to this file — do not improvise criteria.

4. **Analyze & assess**: Fetch each transcript with `mcp__claude_ai_Notion__notion-fetch`. Score each transcript against every dimension defined in the skills file loaded in step 3. Apply the criteria exactly as written — do not add, substitute, or skip dimensions. If you think a dimension is missing from the skills file, flag it to the user at the end of the session rather than improvising.

5. **Identify the top 2-3 weak points**: Name each pattern explicitly across all transcripts reviewed. Quote the exact line where it occurred. Explain what it cost the listener. No generalizations — specific quotes only.

6. **Update the Communication Capabilities Journal**: Search Notion for a page matching `JOURNAL_TITLE`.
   * If it does not exist, create it with `mcp__claude_ai_Notion__notion-create-pages`.
   * Append today's entry at the end with `mcp__claude_ai_Notion__notion-update-page`:
     ```
     ## [YYYY-MM-DD] — [Meeting title(s) reviewed]

     **Strong:**
     - [what worked + specific example from transcript]

     **Weak points:**
     - [Pattern 1]: "[exact quote]" — [what this cost the listener]
     - [Pattern 2]: "[exact quote]" — [what this cost the listener]
     - [Pattern 3 if applicable]

     **Recommendations:**
     - [Concrete drill for Pattern 1 — an actual alternative phrase, not a principle]
     - [Concrete drill for Pattern 2]
     ```

7. **Schedule Comms Prep**: Create a Google Calendar event with `mcp__claude_ai_Google_Calendar__create_event`:
   * **Title**: Comms Prep
   * **Date**: Next workday (skip Saturday and Sunday)
   * **Time**: `PREP_TIME` local time, duration `PREP_DURATION` minutes
   * **Visibility**: Private
   * **Description** (plain text, no markdown): the specific communication patterns to train on from the weak points above + for each pattern a concrete example of what better looks like — an actual phrase to rehearse, not a principle to remember.

## Guidelines

* **Quote the transcript**: Every weak point must be backed by an exact line. "Communication was unclear" is not feedback. "You said 'latency is within acceptable range' without establishing what range the client cares about" is.
* **Score, don't just describe**: Be specific, no-BS sugar coating. Brutal honesty.
* **One criteria set, every session**: Scoring against the same skills file each time is what makes sessions comparable over weeks. Do not improvise new criteria — flag gaps to the user instead.
* **Comms Prep description is the product**: The calendar event description is what the user reads the next morning before practicing. Write it last, make it specific, and make it actionable. A vague description defeats the purpose of the whole workflow.
* **Missing transcripts are not blockers**: Note them, assess what you have, and flag the gap at the top of the journal entry.

## Skills file

The skills file is a plain text or markdown file that defines what good communication looks like in your specific context. It is read in step 3 and used as the scoring anchor throughout the session.

## References

* Google Calendar: `mcp__claude_ai_Google_Calendar__list_events`, `mcp__claude_ai_Google_Calendar__create_event`
* Notion (transcripts + journal): `mcp__claude_ai_Notion__notion-search`, `mcp__claude_ai_Notion__notion-fetch`, `mcp__claude_ai_Notion__notion-create-pages`, `mcp__claude_ai_Notion__notion-update-page`
* Google Drive alternative: `mcp__claude_ai_Google_Drive__search_files`, `mcp__claude_ai_Google_Drive__read_file_content`
* Microsoft 365 alternative: Microsoft Graph MCP server — SharePoint and Teams transcription

The Notion MCP connection handles transcript retrieval, journal updates, and a timeblock for following up on my communication flaws. I call it “Comms Prep” and the agent schedules it automatically.

Important: you have to make sure that your transcripts land in Notion before the agent is run.

The agentic output

Here’s a real entry from my Communication Capabilities Journal, generated after a client infrastructure review and a coaching 1:1:

That’s the best part - you can’t self-assess accurately in real time, but the agent creates your awareness about where you’re excelling and where you’re falling short, based on the call transcriptions.

The calendar training slot

The agent creates by default a 30-minute slot in the calendar at 10:00 local time, with specific instructions what to focus on:

After three weeks, I’m improving on one dimension. The other two are moving more slowly. I now know which one to focus on next week. Before this, I was guessing.

On the data source

The agent works from wherever your transcript lands in Notion:

• Notion AI integration for calls recorded natively in Notion;

• Gemini Notes in Google Drive if you’re in a Google Workspace environment - transcripts land in Drive automatically after Google Meet calls, and you can sync them to Notion via a simple automation; you can make it even more simple by accessing the G Drive directly using the Workspace MCP Servers.

• Microsoft Teams transcription if that’s your stack – transcripts go to SharePoint, push them to Notion via Power Automate or Zapier.

The skill.md file and the Comms Prep scheduling step work the same regardless. The only variation is how the transcript gets into Notion in the first place.

I share the tools and techniques that I apply on my job every day - let me know what you think of the Comm Coach Auditor agent. Also, please reach out to me if you’d like to further fine tune it or have trouble getting it configured the way that you want it - I will gladly help!

And in the first call the client asks multiple questions for which he didn’t have an answer.

UH oh. I felt my stomach drop. I hate leaving meetings where my team isn’t creating clarity.

Look, before you jump to any conclusions 😅 - he’s really sharp and I love his enthusiasm. If he’s reading this… know that I enjoy every minute working with him 😎

So what happened?

A bit of context: our client runs a cloud pipeline that produces metrics for their product team. Every week, they need to know whether the infrastructure can deliver those numbers on time. The questions that they ask are simple:

• How much time does the car engine need to warm up? (how fast does the cluster provision compute when you need it?)

• How quick does the car go from 0 to 60 km/h? And from 60 to 90 km/h? (what is the compute provisioning distribution in time?)

His job was to analyze the infrastructure, measure its characteristics, and explain what it means for the client’s roadmap.

After the call I sat down with him to debrief.

I started explaining that the client actually needed to know when does the engine start and how quick the car gets to 90 km/h. Not a technical summary of how the engine was built, but a clear picture of what it can do - the cloud system’s capability to provision compute within a given time window, the distribution of that latency, and what that means for product inclusion decisions.

I got about two sentences in and stopped. I could feel what good looked like.

BUT - I suddenly felt my mind was blanking on me. I was struggling with saying it in a way that can be CLEARLY easily understood. Like knowing that you have to cross the river but you’re missing the bridge.

Recognizing a communication failure is not the same skill as naming it.

I’ve watched engineers give updates that answer a different question than the one that was asked. I’ve seen technically correct dashboards that leave the viewer with no idea what to do next.

Being able to describe it with enough precision that someone else can avoid it - that’s a different competency.

But I just called it a communication failure - whose was it, though?

Let’s take a look again - the engineer needed to produce:

• A view of the infrastructure’s capability to provision compute within a given time window - the distribution of it. How long does it take to spin up a given amount of VMs?

• What does the variance look like? What does that mean for the product team’s deadline commitments?

What I described: the output I wanted.

What he heard: what to put in the report.

But what the client needed: a frame for making a decision.

Do you see what’s happening?

I’m completely failing to underline how his works helps the client make the decision.

So I decided to do something about this.

I recorded my last 1:1 with my engineer and I ran the transcription through an agent I configured in Claude Code. It reads the transcript against a communication skill rubric:

• clarity of recommendation - does the listener know what to do after this call;

• the ratio of questions asked to questions resolved - am I leaving open loops;

• whether technical detail is anchored to a decision the listener actually faces.

The agent surfaces I’m making the other person work too hard to extract the point.

First report flagged something I hadn’t expected: I state conclusions without anchoring them in what the listener already knows.

That’s exactly what happened in the coaching conversation. I described good communication from inside my own mental model - without checking what frame the engineer was working from.

I gave him a destination without a map.

This isn’t the only gamechanger… the agent books a 15-minute block - dad life means I’m strapped for time these days 😅 - in my calendar each week to practice the specific skill it flags.

Also: it reassesses on the next call and tracks whether the pattern is changing.

On Thursday, I will post the Markdown files for the agent and how to configure it with the videocall transcription notes as well as how to integrate it with the calendar.

See you then!

PS. On the weekend I took part in a local race and ran up the local mountain Uetliberg in under 40 minutes. Really proud of that 😎

First thing waiting for me: weekly status report due. UGH.

Yes, I get it - we all need to highlight the work to our bosses, clients. We want to give our directs the visibility. When written correctly, their promote the innovation and the hard work.

But it’s one of the tasks that feel like sand in the engine… not because it’s hard, status reporting isn’t hard. But the two hours it takes to do it properly arrive at the worst possible time, every damn time.

I detest status reporting with fiery passion.

When something is already on fire, the last thing you need is an administrative obligation.

It like the job was sabotaging itself, and the act of me writing it feels like I’m complicit in it.

What feels the worst: me sending out individual messages to my directs asking them to summarize their own impact - hey, what’s the one thing you shipped this week that actually moved something? - and the ensuing context switch cost that they have to pay.

Every week. Two hours. Kill me.

Long story short - I built an agent for Claude Code to do it instead. More on that in a companion post (link at the end of this article).

I’m happy to report that last week I had my two hours back.

Here’s what I did with them.

60 minutes - to be a better leader

By preparing for a coaching session with one of my directs who’s working through a hard challenge.

Brutal honesty: I usually walk into these conversations with good instincts and not enough preparation. This time I had time to actually think before I sat down:

What outcome do I want to achieve in the 1:1?

That preparation changed the quality of the conversation. I had been trying to get there for months.

15 minutes - a coffee chat with a peer who just became a father

He needed to talk and I had the time!

45 minutes - spend time with my 4-month old son

He’s so awesome.

AI doesn’t replace a conversation, an inspiration, a relationship

I’ve been thinking about what AI for managers actually means. Most of the conversation is about automating coding away.

But the more interesting question is: what work should a manager never have been doing in the first place? Do we really have to be forced to writing faster, summarizing longer, organizing better in this agentic era?

Status reporting is one answer. Yes, information is important, but mainly because its value is in leadership receiving it, not in me spending two hours compiling it manually every week.

An agent handles the compilation, but I handle the judgment calls the report can’t capture.

To me, that’s the real benefit of using AI, the division of labor - the agent pays the administrative tax, while I focus on relationships, conversations, inspirations.

The weekly-reporter skill file, setup instructions, and a sample run output are in my article The last status report you’re write by hand

Artifact review, merged PR checks, chasing contributors for impact summaries. All of it manual… every single week.

So I built a Claude Code skill to handle it. And I’m sharing the full file here - drop it in, configure two variables, and run it.

What you need

• Claude Code installed and running;

• GitHub CLI (gh) authenticated with repo access;

• Notion MCP connected to Claude Code (or swap for Google Drive, Jira, or M365 (more on that below);

• GitHub handles of the contributors to report on.

The skill file

Save the following as SKILL.md inside ~/.claude/skills/weekly-reporter/SKILL.md.

# Weekly Reporter

> Compiles a weekly executive summary of impactful achievements for specified
> contributors by scouring Notion and git repositories. Use when generating
> status reports, impact summaries, or performance review inputs for individuals
> over a one-week period. Do not use for real-time status checks, daily
> standups, or when no contributor names or handles are provided.

## Configuration

REPO_SEARCH_PATH: ~/your-code/*   # glob — adjust to match your repo layout
LOOKBACK_DAYS:    7

Adjust REPO_SEARCH_PATH before running (e.g. ~/code/** to search recursively,
or ~/work/acme-* to target a specific org). The agent resolves the glob with
find $REPO_SEARCH_PATH -maxdepth 0 -type d before running any git commands.

<!--
SWAP THE DATA SOURCE — Notion is wired up below, but you can replace step 2
for any of these MCP integrations with minimal changes:

  Google Drive   — tools: search_files, list_recent_files, read_file_content
                   Best for: teams on Google Workspace (Docs, Slides, Sheets).

  Microsoft 365  — tools: search via the Microsoft Graph MCP server
                   (SharePoint, Teams messages, OneNote notebooks)
                   Best for: enterprise orgs on M365 / SharePoint.

  Jira           — tools: search_issues, get_issue via the Atlassian MCP server
                   Filter by assignee + updated date to pull completed tickets.
                   Best for: engineering teams tracking work in Jira sprints.

For code: GitHub (gh CLI) is shown below. GitLab users substitute glab.
-->

## Overview

This skill guides the agent in compiling an executive summary of achievements
for a given set of contributors over the last week.

## Workflow

1. Confirm Inputs: Ensure you have the list of contributors (names or GitHub /
   GitLab handles) and the target date range (default: last LOOKBACK_DAYS days).

2. Scour Notion:
   - Use the Notion MCP search tool to find pages authored by or mentioning
     the target contributors within the lookback window.
   - Fetch the full content of relevant pages.
   - Query recent meeting notes involving the contributors.
   - Prioritize pages with titles indicating progress, status, design, or
     impact (e.g. "Status Update", "Design Doc", "RFC", "Spec").

3. Analyze Code Contributions:
   - Resolve REPO_SEARCH_PATH to a list of git repositories with:
       find ~/your-code/* -maxdepth 0 -type d -exec test -d {}/.git \\; -print
   - For each repo, list recent commits:
       git -C {repo} log --author="{name}" --since="{LOOKBACK_DAYS} days ago" --oneline
   - GitHub: list merged PRs:
       gh pr list --author="{handle}" --state=merged --limit=20
     Inspect with: gh pr view {pr_number}
   - GitLab: substitute glab mr list / glab mr view
   - Only include merged / landed contributions — exclude drafts and open PRs.

4. Compile Executive Summary:
   - Synthesize findings from Notion and the repositories.
   - Structure with: Key Achievements, Code Contributions, Design & Documentation.
   - Focus on impact — not activity.

## Guidelines

- Focus on Impact: highlight what was achieved, unblocked, or delivered.
- Be Concise: summaries should be punchy and easy to scan. 1-2 sentences per
  item, mapping Action -> Impact -> Proof directly.
- Verify Dates: all activities must fall within the LOOKBACK_DAYS window.
- Prefer CLI for Code: use git and gh/glab directly — not web or API calls.

How to invoke it

Open a Claude Code session and run:

Use the weekly-reporter skill for the following contributors:
handle-1, handle-2, handle-3
Time range: last 7 days

It runs git log and gh pr list per contributor, searches Notion for relevant updates, and compiles the summary. Takes 2–4 minutes.

What the output looks like

Here’s the output from a run I did this week:

Weekly Report — May 3–10, 2026

Key Achievements

Shipped the core content asset for the weekly-reporter launch. Wrote and
iterated a full Substack draft — "I automated status reporting. This is what
I did with the time." — built around a personal management story (2 hours
reclaimed, how they were spent).

Validated the keepmomentum.eu market position with data. Completed a
comprehensive competitive analysis covering the $7.3B global coaching market
and the $1B+ AI coaching segment. Confirmed the target gap: no individual
practitioner is offering AI-assisted skill practice directly to engineering
managers. BetterUp leads the enterprise tier with $567M raised and holds
0.12% of the HCM market — the category is wide open.

Code Contributions

Commit   Date    Description
92f3c9d  May 9   Add Google Analytics 4 alongside existing Google Ads tag
f1b8749  May 9   Add email course section as soft secondary CTA

Both landed directly on the main branch. No open PRs.

Content & Documentation

Artifact                                        Type              Status
"I automated status reporting…"                 Substack draft    Draft — needs cold read
"I use AI to automate status reporting…"        Substack draft    Superseded by above
"I built an AI agent that handles my report"    LinkedIn post     Draft — scheduled May 20
Market analysis                                 Research doc      Complete

---

On tool calls: this run made 8 tool calls — 5 against Notion
(searches/fetches) and 3 against Bash (git commands + repo scan).

Two hours of manual work. Five minutes of review.

Configuring for other data sources

The skill ships with Notion wired up. The comment block at the top of the file shows exactly which MCP tools to swap for Google Drive, Microsoft 365, and Jira - change step 2 of the Workflow to point at the right tools, and the rest of the skill runs unchanged.

For anything else: if it has an MCP connector and you can search it by contributor and date, it can slot into step 2.

If you set it up and run into something, reply here. I’ll help you debug it.

At the project start, I felt that the customer pain was real. I had belief that our engineering was solid. The improvement shipped.

But nobody really cared.

That was the painful lesson: solving a real problem is not the same as solving the right problem.

We had listened to the loudest complaint, but we had not understood the full user journey. And that difference cost us six months.

How is that possible? Didn’t you do any due diligence?

The squeaky wheel gets the oil

A complaining customer - “Perfect”! I thought. “We have a clear-cut problem and a person to provide us all the requirements, and feedback during the implementation process”.

The tests are running super slow because of the slowness in the playback of the test data. Having this bug is super annoying. It adds friction to our work.

Let me tell you how testing in my project was crucial.

When designing hardware in disciplines like Augmented Reality, that aims to “understand” the real world, you need to test it with data that resembles the realities of where it will be used. For instance - the data is a video from first-person perspective of looking at an object in an office room.

The data is piped through the system to produce the ‘PASS’ or ‘FAIL’ - unfortunately for our client, it was packaged in a way that made it really difficult for the testing framework to deal with it efficiently.

And you need a lot of diverse data to frequently ‘probe’ the product for any defects in order to ensure its high quality.

“We’ll solve it for you”, I joyfully told the client.

I felt satisfied with the request, as I heard a very clear pain point that I could cash in on. My thought process was: OK, we have a (loudly) complaining client, we have to analyze the issue, solve it, deliver the fix and then sip champagne.

Lesson #1: Working on a misunderstood problem means doing ‘busy work’

Hold on - but isn’t the problem already defined?

The customer has problem with the tests being slow. That sounds like obvious value added. You can’t understand the problem only having the opposite perspective - you need to put in the rigor and work to paint the challenge from the system point of view, too.

The test framework was used in two scenarios - off-device and on-device.

The use case where my team principally focused on was “off-device” which meant a quick & easy way to schedule the test run, as opposed to the “on-device” case that required the engineer to look for a physical device, boot it and configure it, upload the feature that they’re working on and then run the test.

We should’ve stopped there.

The logical decision at the time was “off-device” because it seemed to be easier to address. “On-device” support was punted down because it had hardware limitations barring it from being incorporated.

Only a limited part of the problem was understood and not the entire user journey, that was critical to uncover the pain points that our customers were experiencing.

In reality, it was the “on-device” variant that was the actual problem - the users had to go through all the hassle of preparing the hardware for test, the slowness in the testing framework added to the frustration of the user. It was experienced, it was visceral.

Misinterpreting the actual issue had consequences:

1. Pain point persisted - the “off-device” tests were executed automatically, and no human was in the loop, meaning - no slowness that can be “experienced”;

2. No visible user satisfaction after six months of work caused our demotivation.

It was just busy work that scratched my “another feature delivered” itch.

Lesson #2: It’s bad business to serve just one customer out of many

If you’re in the business of selling apples, will you make more money selling one apple to a single client, or to two clients each?

The answer is obvious - but I took another path.

The test framework we set out to improve was used in different ways. The clients ran the tests in different ways - they liked to write and execute their own custom scenarios.

“The datasets that I’m running are pretty short and I’m not impacted that much by this problem”, we heard from another customer, upon offering to roll out the improvement to his team.

“We’re mainly running the off-device tests and we’re seeing 16% speed improvement - not bad by any means”, said a developer representing yet another client.

A dangerous pattern emerged - the clients were voicing dissent.

A fix was worked on and delivered, and not only was it not serving the critical consumer case of the one client (because it wasn’t working on-device) but the other clients simply didn’t care for it.

It didn’t bring them any value.

What was missing: thorough due diligence into our entire audience and not only its subset represented by a single client. A cardinal mistake of a business offering their services.

Lesson #3: Inspecting your own results helps you release a better product

Build-inspect-learn loop is the flywheel of self-improvement and helps identify points of improvement for the product team.

“Let’s try to improve the off-device test execution for as many teams as possible”, and we concluded the project shortly after that.

I feel that the six-month period took a lot of energy out of us. It was a period where we tackled arising complexities, managed relationships with our clients and aggressively decreased scope wherever possible to avoid the scenario of digging ourselves into a rabbit hole.

But it was a time of learning, too, that needed to be revisited and distilled into concrete, specific steps and action items that propelled us to take on more fruitful challenges.

We reviewed everything that we did - from the added support for parallelism in data ingestion, optimizations for streaming compressed data quicker, many small improvements in the housekeeping code.

That wasn’t yet the time of agentic AI, mind you - most of the software engineers on the team didn’t have professional experience with C++, so it was a huge jump in terms of the tools used.

There was a tremendous boost of self-confidence and the belief that now we could deal with any problem and overcome it in a quick time.

It also made everyone aware of how critical it is to think outside of the “software” box, given that the most of performance improvements in our testing framework could’ve been made had we understood the entire user journey.

Build, inspect, but foremost - learn to succeed

In the ensuing months we went to apply our newly discovered strengths.

We went on to deliver a feature, that saved thousands of hours for the users of our testing frameworks - by going the distance and compiling a list of thoroughly investigated problems, we’ve adopted a strategy where we forced ranked each problem by the amount of customers that it was impacting.

By compounding the time saved by the multiple clients that we served, we were able to obtain time savings unattainable without:

• fully understanding the problem;

• identifying customers benefiting from it;

• keeping the learning feedback short & always closed.

Ultimately, time savings are equal to money saved for the organization.

It was an experience where I realized that even as a manager in a large company, you got to think like a small business owner - operating like your lifeline depended on not only providing a good level of service, but knowing the clients inside out and the problems that they face every day.

Before you build, learn where to look

The story above is one version of a mistake many builders make: we fall in love with the solution before we fully understand the problem. That is expensive inside a company.

It is even more expensive when you are building something of your own.

Barbara and I created USER-DRIVEN BUSINESS IDEAS to help you avoid that trap. It is a free six-lesson email mini-course for busy professionals, creators, consultants, coaches, and aspiring founders who want to start a business, but feel stuck at the idea stage.

The course teaches a simple process for finding real customer signals, spotting repeated frustrations, asking better questions, and shaping what you learn into a business idea worth testing.

The goal is not to find the perfect idea - the goal is to stop guessing.

Join the mini-course here: https://yourbookhub.aweb.page/discover-idea-building

AI agents are excellent at solving isolated function-level problems but notoriously bad at maintaining system-wide consistency or handling non-standard constraints. Subject matter experts need to be aware of that.

When auditing one of the projects for a client, I took a hard look at a solution that had almost entirely been vibecoded. It did solve the problem at hand, but was plagued with many problems - starting with poor maintainability, no documentation and worst of all, its logic was so perplexingly complex and diluted that eventually my team decided to rewrite it.

Until we pulled the trigger on that, it had a long-term negative effect on the engineering team continuing that project. For several months nobody was confident about making changes that could break the product, and having it offline for an extended period of time was obviously a no-go.

We don’t live in a perfect world and there are always factors that affect optimal decision making when executing on a project - looming deadlines, lack of specific knowledge, or unplanned absences in crunch times.

That is all good and valid, but one shouldn’t sacrifice understanding the big picture of the system for quick gains in output. Even if the skills or talent aren’t there, there are still ways to supplement own effort and understanding using an AI-based approach.

Effect of lack of ownership: creation of wasteful solutions, increased effort for future improvements actually addressing the new system challenges.

The quick lever: ownership of the outcome always starts with self-awareness; to counteract it, a quick and easy way to elicit such self-reflection is to run simple prompting for adopting a “contrarian view” or a sparring partner:

1. “Pre-mortem” analysis: conduct a ‘pre-mortem’ on this design. Assume it is 6 months from now and this solution caused a critical incident in production. Describe the exact sequence of events that led to the failure and identify the root cause.

2. Feedback à la “ruthless minimalist”: act as a strict, minimalist Principal Engineer who hates adding new dependencies, critique this proposal and argue why it is over-engineered. Suggest a simpler alternative that uses only our existing stack.

Boosting own productivity at the cost of others’

Many AI tools are adept at centralizing knowledge and capable of rapidly creating documentation. Such low entry barrier for synthesizing information makes it easy to fall into a false sense of rapid productivity and value creation, especially if the end product fails to create the expected level of clarity. No clarity means time wasted by others reviewing, commenting, and following up on it.

Not so long ago, whiteboarding and the creation of “demonstrative” code changes used to be the standard for proposing changes to existing systems. Ideation, exploration and consensus building was always achieved among humans, and it will remain so.

In the meantime, productivity tools and platforms providing first-class support for distributed teams have elevated the process of asynchronously building understanding.

Knowledge organization has advanced, too — tools such as Obsidian, Notion or NotebookLM allow the ingestion of institutional knowledge in all forms: documents, audio or video recordings. It’s a no brainer use case for AI integration — by creating a specific context, one can quickly synthesize new data based on the provided artifacts.

But coming to such quick outcomes doesn’t mean that one exercises ownership, in fact it means the opposite; without refining and intentional editing of the artifact, the author risks wasting the time of fellow reviewers at the benefit of own time savings.

The feeling of the LLM “getting you” doesn’t mean that others will.

Let’s take work ticket descriptions as an example. Ticketing tools now generate first drafts for descriptions and other data necessary to make it clearly known, what the work should be about. If the author relies purely on the AI-generated text and doesn’t own the description, it causes:

• resentment of not putting enough effort into documenting what should be done;

• as a consequence, having the label of a corner-cutter;

Effect of lack of ownership: reviewers lose time and perceived “productivity gain” is a net-negative for the team.

The quick lever: the leader must react swiftly whenever this happens, and employ very basic, albeit targeted coaching. Consider the following questions (and statement):

1. Imagine you’re out sick tomorrow. Can another engineer start without a meeting? If not, what’s missing?

2. How much time did this save you? How much time will it cost reviewers to interpret?

3. Add a 5-line decision log: options considered, why we chose this, and what we’re deliberately not doing.

In the first question, the individual should realize that the “bus factor” is very real and that it exposes them as a potential blocker. The self-reflection of the second question should ideally lead to the fact that one ought to optimize for team time, not author time. The last statement is the most powerful of all, because it equips the individual with the notion that they have the agency to create recommendations for others. When the self-realizations will have successfully led to crafting a much better documentation, the individual knows how to progress from “specialist” to “expert“ mode by relieving others of the responsibility to scrutinize and quality-check their work.

Manager escalation as communication avoidance

Communication in a well performing team is like oil to an engine - one doesn’t work without the other. Team members solve problems because they understand the assignment. They understand the assignment, because they communicate.

One can’t simply defer stakeholder communication to the manager anymore. In the past, team members would come to me and signal problems that should be escalated or articulated to other team leads and would ask me to do my “manager thing” and take care of that. In a high-pace environment, it’s relied upon the leadership of the individuals to build bridges between stakeholders and influential actors on a project.

AI agents already automate large portions of manual work. The degree of automation is expected to rise - at some points models will become so advanced and have the contextual coverage of the entire knowledge base of an company.

Many engineers still cling to their technical expertise as if it were their biggest asset. But the low entry barrier to programming - now essentially anyone can become a programmer - means technical execution is becoming more accessible.

The role of the subject matter expert in the field of technology nowadays is that of an auditor of the AI agent output, adjusting the prompt to cover the intended technical solution or whether to rewrite it again.

Writing code is no longer the most valuable asset one can produce - communication, judgment, and ease of alignment are becoming more and more of a differentiator.

Effect of lack of ownership: individual misses out on increased impact & visibility across other teams / departments, diminishing own career growth.

The quick lever: turn “problem escalation” into “proposal ownership” - before asking the manager to “do their thing”, ask the team member to do the following:

1. The 3–5 sentence message they would send;

2. Articulate what is needed from the other party;

3. Two options and their recommendation.

This increases individual ownership because it has the individual realize what the situation is, instead of the manager doing that, after context-switching and trying to debug what’s going on.

Moreover, the main reason for failing escalations is that the “what” isn’t formulated well - making the ask explicit is ownership of outcomes, not activity. Ultimately having the recommendations is the biggest upgrade as it signals: I’m thinking like an operator, instead of Oh, I’m waiting for prescription. Even if the recommendation is wrong, it’s at least coachable as it builds the “ownership muscle”.

Treating the agent as an oracle

The paper Your Brain on ChatGPT: Accumulation of Cognitive Debt… describes a pattern I’ve started recognizing in engineering teams too: when the assistant does too much of the thinking, the human’s sense of ownership and engagement tends to drop quietly.

In engineering, this shows up as a dangerous bias: the AI overlord has the answer. But an agent’s “wisdom” is not universal, it’s highly contextual - as it should be.

And it serves many companies well: optimized for the org’s main domain, its tooling, its stack, its institutional knowledge, etc. That’s exactly why it can be so effective… and exactly why it can be misleading outside that context.

Subject matter experts then let rigor sink: they accept a polished proposal, skip the uncomfortable step of consulting teammates who own adjacent constraints (security, infra, data, product), and ship an answer they can’t fully defend.

Effect of lack of ownership: missed constraints show up late (when they’re expensive), and the team can’t explain or defend the decision under pressure.

The quick lever: one AI answer requires one human dissent - before proceeding, the owner must do two things:

1. Name the constraint owner they’ll ask for a 5-minute sanity check (security / data / infra / product);

2. Write 3 assumptions the AI made that could be wrong in our system;

3. Capture one dissent (a concern, alternative, or “this doesn’t apply here”) and either address it or explicitly accept the risk.

I’ve seen over and over how good leadership has accelerated my team members gain responsibility, get visibility and helped get the job done way ahead of time. Therefore it’s a leader’s duty to apply all the collective skill and will to help learn, have fun and ship value every day.

My framework is composed of the following tools:

1. Universally-understood standards for excellence

2. Clarity of expectations

3. Collaborative goal-setting

4. Relentless coaching, constructive feedback

Let’s dive into it!

Universally-understood standards for excellence

How should the team members carry themselves?

Standards of excellence mean your team knows not just what to do, but what ‘above the line’ looks like on a normal Tuesday. No team will perform at a given level unless the bar is set. When thinking about setting standards for excellence, think about an athlete focusing on core training aspects that will bring them to a medal.

My go-to combination of standards of excellence: ownership, communication, effort and impact.

But this list alone simply doesn’t cut it — concrete examples of excellent work are a must and conversely, of subpar work as well. They need to be relatable as well, otherwise the path to excellence will not be understood.

Consider the following example that I use to explain to my team how to meet the standards.

A platform engineer discovers that one of the product services is struggling to keep up with the incoming requests and is failing to pass the system health checks.

1. Ownership

   1. ✅ Above the line: discovering latency issues, ensuring all impacted individuals are informed or involved in the process.

   2. ⚠️ Below the line: raising latency issues but doing nothing above that. Assuming “everyone knows what’s happening” and stopping there.

2. Communication

   1. ✅ Above the line: directly answers “how bad is it” so that the consequences are understood.

   2. ⚠️ Below the line: provides information but no answers; teams and individuals are not aware what are the consequences.

3. Effort

   1. ✅ Above the line: system-thinking approach allowing to understand why the issue appeared.

   2. ⚠️ Below the line: focusing on the what the fix is and not the why it occurred.

4. Impact

   1. ✅ Above the line: tracks the short and long term effect of the resolution. Recommends further improvements.

   2. ⚠️ Below the line: resolves the issue, but misses out on providing a recommendation to improve the system.

Creating clarity of expectations

How do the team members know, they are on the right track?

It’s no secret that working towards unclear outcomes is a waste of time.

This means being articulate in expressing expectations — not being able to do so leads to poor performance and consequentially, poor morale.

When done right, it fosters psychological safety, since everyone is capable of self-managing themselves without getting sidetracked. Everyone in the team then has an intuition of the following collaboration aspects:

• Knowing the team goals;

• What are the operating principles;

• How to communicate efficiently;

• How much freedom there is to make errors;

• When to take time to reflect and learn.

This is very well described in the study Psychological Safety and Norm Clarity in Software Engineering Teams, the summary of the paper is that clear behavioral norms predict team performance and job satisfaction, with norm clarity being the stronger factor.

Bottom line — I reduce ambiguity to the max as a tool to boost performance and morale.

Collaborative goal-setting

Having people accomplish goals their way.

The most successful organizations take pride in bosses who allow their employees to do their job. For us, as bosses, this means reminding ourselves to step out of our directs’ way and let them find their own path to meeting the objective.

In my teams, I clearly lay out the foundation for our success by setting the larger vision. For example:

Make our service the #1 solution for prototyping across the company.

With that intention out there, I invite everyone to apply their creativity in searching the quickest and most sustainable path to meeting that objective. The culture letting others decide the route to the destination (individual goal setting) and the vessel (selection of tools for the job) is the main force multiplier for combined performance and motivation.

Not micromanaging doesn’t mean no expectations - in fact, the greatest results come when expectations are set and autonomy is guaranteed by the leader.

My secret for 10x performance: setting goals by finding opportunities for intersecting individuals interests with team goals - the greater the overlap, the better. It’s not easy to do that, and let’s face it - we’re hired to tackle company goals - but my belief is that it’s on me to have the people buy into the idea of pursuing growth based on current needs. It’s not through any kind of manipulation, but rather by spending time in a 1:1 and dissection of pros and cons of development areas, and how they best convert onto added value to the project.

Relentless coaching, constructive feedback

Grow, adjust, learn, repeat

I put coaching and feedback last in my performance framework, but it’s my favorite part. Nothing beats the satisfaction of applying coaching and feedback to an aligned goal and seeing the person grow.

In coaching, I emphasize helping the individual find their own path to the destination; feedback acts as an aid to help them stay on that path.

Coaching and feedback also give a powerful opportunity to truly get to know the human sitting on the other side. The great thing about it is that most of it comes down to listening actively — and occasionally asking questions or sharing your perception of their behavior and the impact it has on the world around them.

Yes, it’s that simple.

But one should not fall into the trap of thinking about delegating as an isolated element, but rather as a crucial building block of a high performing team.

How does effective delegation transpire into a team performance? Consider the following relationship between delegating, ownership and performance:

Delegation → Responsibility → Trust → Accountability → Ownership → High Performance

Read on to learn how delegation leads to high performance.

Before delegation: the overwhelmed leader

When you delegate, you give someone the chance to take responsibility for an outcome. If they succeed, they earn trust.

Moreover, it allows the leader to focus on the strategically relevant tasks and use the bandwidth in areas where the direct report currently lacks the insight or expertise.

Effective delegation is a challenge for leaders on all levels, not only among inexperienced people managers. Usually, incapability to effectively delegate manifests itself by the feeling of being overwhelmed by amount of “things to do”.

It’s detrimental to leadership capabilities, as when the inability to delegate persists in time, the team members grow indifferent to new challenges and even tend to refuse to take them on.

When this happens, the team gets stuck performing at an average level - people stop growing and the team’s ability to deliver good work plateaus or gets worse.

Delegation in action: responsibilities distributed

This can quickly change by delegation: the team lead doesn’t need to be focused so much on execution as architecting the distribution of responsibilities among team members.

By resorting to delegation, a minimum level of trust has to be placed in the capability of bringing the assignment home and ensuring that the direct report has free reins on the “how” - the boss decides merely on the “what”.

Accountability emerges: one individual orchestrates the broader outcome

There are distinct differences between responsibility and accountability:

Accountability is about ensuring that a broader assignment is completed. Responsibility is about completing a task within that broader assignment.

Imagine an event manager who organizes an investor dinner - they are accountable for running the event (venue, catering, program) but the catering specialist is responsible for putting the menu together.

Key difference: accountability is about ownership of the complete outcome, while responsibility is about executing specific tasks that contribute to that outcome.

The logical conclusion is that with an increase in responsibility comes more trust, and as trust grows more confidence can be placed in the individual to deliver larger assignments.

Eventually, one person can’t handle everything alone - they need help from others. This is the key moment when responsibility turns into accountability.

As more people get together to complete the assignment, represented by that accountable individual, she is the bearer of end-to-end ownership.

The payoff: shared growth

But here’s the best part: the team leader benefits too. When you delegate work, senior leaders start to trust you more, thanks to this simple outcome:

1. You trust your team and give them work → they complete it successfully.

2. This builds more trust, so you give them bigger responsibilities.

3. As ever larger responsibility morphs into accountability → the team naturally embraces ownership.

4. With ownership your team’s influence expands.

High performing teams efficiently find ways to expand its influence and positively affect the lives of others - other partner teams, the entire division or simply achieve increasing higher satisfaction levels among their customers.

Each time you hand over responsibility, you’re planting a seed of trust. With time, those seeds grow into ownership, accountability, and eventually → high performance.

One thing that’s been lately on my mind is the beginnings of my management path… how it all started and if given the chance, what I’d want to do better from Day 1.

Needless to say—a lot 😅

“Is there a list of actions for a newly crowned leader to take for the strongest start?” is the challenge that I set out to tackle in the last few days. I believe it’s necessary to share my personal pointers on not only what I’d do differently, but more importantly what has worked out great, too!

If you, my dear reader have recently been promoted from an IC role or just joined a new company as a seasoned leader, your first few days will set the tone with the team. I’ve been there—and I’ll tell you the one thing I wish every manager knew from Day 1.

My first week as a manager? A rollercoaster.

Starting a new job as a manager can feel incredibly overwhelming! I remember my first managerial role—it was terrifying 😅

I had many questions in my mind with no clear answers:

• How should I establish the right relationship with my now former peers?

• How can I demonstrate that I'm the right person for this role?

• What should I focus on besides coding? After all, coding skills got me promoted, but now I have no idea what else being a manager involves, help!

During evenings when I would be pondering about what happened at work, I kept imagining how much efficiently and gracefully I would handle some difficult situations.

Years later, after coaching dozens of managers and leading interdisciplinary teams, I’ve learned one truth:

Every new manager should do everything in their power to start building their trust capital as soon as possible.

Why does trust matter so much?

Many new managers make two basic mistakes:

• They don't build trust with their team;

• They aren't open about their plans and decisions.

The result? A slow-motion trainwreck:

1. Difficulty leading—because you need your team to believe in and support your goals. No trust, no buy-in!

2. Decreased performance—without effective leadership, setting expectations and giving feedback becomes ineffective. As a result, a manager struggles to drive performance.

3. Limited visibility—Greater impact leads to increased organizational visibility. And don't say "This doesn't apply to me, I'm a new startup CTO with a small team"—it absolutely does! Unless your team delivers excellent work, you're less likely to positively impact your clients' lives, which inadvertently weakens your personal brand.

Unfortunately, directors (or managers of managers) rarely provide clear guidance for those first few days. The expectation is that you'll figure it out on your own.

From my observations, managers new to the job usually start their managerial career to sticking to what they know best—contributing individually. It makes sense because it’s what got them promoted in the first place. Paradoxically, it’s not setting them up for success as engineering managers!

If you stick to what got you promoted (like coding or firefighting), you’ll stay stuck as a glorified IC.

Let me tell you one thing—it's far better to start building your leadership from day one.

How to start filling your trust chest: A 3-step plan

But first—let’s get one thing clear: Trust is your leadership currency.

*Think of trust capital like a chest you carry into your new role. Every action that builds credibility—listening, being transparent, following through—drops another coin into that chest.

The more coins you collect, the more “purchasing power” you have to make changes, ask for support, and lead through challenges. No coins? No influence.*

So… how do you start filling that chest in your very first week?

1. Run insightful 1:1s

Schedule a 1:1 with all of your direct reports—get to know everyone.

During your conversation, make sure to ask the following question:

“If we made just one change to how this team works, what would make the biggest difference for you?”

Why it works:

• It shows you care.

• It gives you insights to improve the team.

• It signals you’re thinking like a manager, not an individual contributor.

I trust that you have enough empathy and curiosity to learn about others and hear their stories, though there’s one universal truth—you only have one chance to make a good first impression.

⚡️ Titan tip: phrasing the question this way stimulates creativity and helps envision positive outcomes under your leadership. While they may not say it directly, their answers reveal what they expect from you as their manager.

2. Share what you heard

Once you’ve gathered insights, synthesize them into 2–3 key themes.

Then play them back to your team and peers. This can be in a form of a or a quick sync, nothing too fancy. The important thing is to acknowledge everyone’s point of view.

Try something like:

“Here’s what I heard in my 1:1s—some things we could improve. Let me know what I missed.”

Why it matters:

• It demonstrates active listening.

• It makes your early leadership visible.

• It shows you’re building from the inside out, not dictating from above.

Once you finalize all of your 1:1s, it’s time to condense all of the precious feedback that you got into and project it to the entire company. What’s the best form of that?

3. Publish your 30-60-90 plan

Write down your goals for the next three months: how you’ll learn, build relationships, and improve the team.

Then—here’s the key—share it publicly.

Post it in Slack. Drop it in Notion. Send it via email. Let your:

• Team

• Cross-functional partners

• And even your manager’s peers

…see what you’re up to!

Such transparency allows everyone to see what you’re up to, sets expectations and shows you’re serious about leading with intent, with positive change in mind.

Leadership isn’t a solo sport

It’s not necessary to have all the answers in week 1. But you do need to show people that you’re here to lead, not just manage tasks.

Start with earning trust. If you do that, everything else becomes easier—strategy, feedback, accountability, and eventually, impact.

⚡️ Titan Challenge: Create your own 30-60-90 day plan based on my personal template (link). I've used this with one of my teams to great success. It reflects the real objectives I set!

Hey Titans,

In the first part of this two-part series, we unlocked how to spark energy and alignment in your team with a Purpose & Vision workshop.

Now, let’s fuel that momentum with something even more powerful: a strategy that brings your vision to life—and gets your team fired up to own it.

At the end of this article, you'll be able to:

✅ Make the vision achievable by creating a specific roadmap;

✅ Increase team engagement by turning abstract vision into a tangible set of actions.

Have you tried the Purpose & Vision workshop yet? What worked—and what didn’t? Share your story in the comments—I respond to every single one.

Why do I need a Strategy?

Going back to the analogy of the LEGO blocks and fire engine, a strategy is the assembly manual that, alongside the box cover image, helps us connect today’s scattered pieces with tomorrow’s finished vision.

Without a strategy, your team might have all the right components—but no clear idea how they fit together. The result? Frustration, wasted energy, and slow progress.

But when the team sees both the big picture and the instructions to get there, something powerful happens: they start building with purpose.

That sense of clarity turns into motivation—and motivation is what drives performance.

And it’s not just a gut feeling. Research shows that when people connect their present actions to future goals, motivation increases significantly. Whether in classrooms or companies, visualizing success boosts focus, engagement, and follow-through [1][2].

On a personal note, when I moved to Switzerland ten years ago, I dreamed of connecting deeply with the community. Speaking the local languages—German and Italian—was key.

I didn’t get there overnight, but I had a strategy: small actions, structured over time, guided by a clear goal. That made all the difference.

Whatever your version of that dream is—whether it’s building a high-performing team, becoming a stronger leader, or tackling a bold personal challenge—it starts with a strategy.

And that’s exactly what we’re going to build next.

How can I create a Strategy?

So how do you actually build a good strategy?

It starts with clarity—on your business, your context, and your biggest challenge. One of my favorite strategy thinkers, Richard P. Rumelt, in his book "Good Strategy, Bad Strategy" breaks it down into a simple framework I use all the time.

Let’s walk through it.

1. Diagnosis

The Diagnosis helps us identify our main problem by asking: "What's stopping us from reaching our goals?" It's like taking a snapshot of where we are now and comparing it to where we want to be, so we can spot what's standing in our way.

2. Guiding Policy

A guiding policy is a simple, clear set of rules that tell you how to solve your main challenge. It's like a roadmap that shows you which direction to take and helps you make decisions along the way.

3. Action Plan

Create a clear action plan that follows your guiding policy. Your actions should be:

• Realistic and achievable

• Focused on solving your main challenge

• Connected to each other in a logical way

• Aligned with your overall strategy

Think of it like building steps to reach your goal - each step should naturally lead to the next one and bring you closer to where you want to be.

Creating a Good Strategy: A practical example

Developing a good strategy is crucial for both emerging tech leads and overwhelmed middle managers. It helps in addressing challenges, aligning teams, and achieving goals.

Here, we'll walk through a step-by-step example of creating a strategy that can be applied in real-world scenarios.

Scenario: Enhancing Team Efficiency through OKRs

Let's consider a scenario where a tech lead wants to improve team efficiency by implementing Objectives and Key Results (OKRs).

Step 1: Diagnosis

What is the challenge?

Diagnosis: the team is struggling with meeting project deadlines due to inefficient workflow management.

Why is that?

Analysis: current processes are manual, leading to delays and miscommunication among team members.

Step 2: Guiding Policy

What do we want to achieve?

Objective: implement a project management tool to streamline workflows and enhance collaboration.

What is the desired outcome?

Key Results:

• Successfully onboard all team members onto the new tool within 6 weeks.

• Achieve a 20% reduction in project completion time within 3 months.

• Receive positive feedback from at least 80% of team members on the new workflow by the end of the quarter.

Step 3: Coherent Action

What are the steps towards achieving the desired outcome?

Action Plan:

1. Research and choose the tool for the job: evaluate project management tools (e.g., Basecamp, Trello) based on team needs and budget.

2. Training and onboarding: schedule workshops for team members to learn the new tool.

3. Monitor progress: regularly review project timelines and team feedback to adjust the strategy as needed.

Summary of a Good Strategy

This strategy example shows three important things: it clearly identifies the problem and its cause, sets a clear future goal, and lists specific actions with measurable results.

When we create a strategy this way, it helps keep the team motivated. This motivation leads to better team engagement, which is essential for high performance.

Consider these key elements when developing your strategy:

• Focus on what matters: A good strategy picks the most important goals and makes sure everyone works together to achieve them.

• Keep it simple: Even when dealing with complex situations, a good strategy should be easy to understand and follow.

• Tackle problems head-on: A good strategy clearly identifies challenges and shows how to solve them.

• Use your advantages: It makes the most of what you're good at to overcome any difficulties you face.

Titan Challenge: Take 30 minutes this week to write down your team’s main challenge, and sketch out a draft Diagnosis–Policy–Action plan. Let me know how it goes!

Just like in my previous article, I’ve got some extras for you!

🧠 Get the free Strategy Builder Worksheet: I’ve turned today’s framework into a simple template you can use with your team right away. Reply “strategy” in the comment section and I’ll send it to you directly!

🙋‍♂️ A Free Consultation: I’m offering 5 free 30-minute “Strategy Jam” sessions to help you work through a challenge using the Diagnosis–Policy–Action framework. Hit reply or drop a comment to claim one—first come, first served.

Sources

1. Simon Pawlak, Ahmed A. Moustafa. A systematic review of the impact of future-oriented thinking on academic outcomes, (2025) (link)

2. Cécile Nurra, Daphna Oyserman. From future self to current action: An identity- based motivation perspective, (2018) (link)

Hey Titans!

Today, I want to share a powerful approach I’ve used to inspire my teams—one that has transformed how we work together and achieve great results.

And here’s the best part: at the end of this post, I’ve got a little surprise for you—something that will help you run this process with your own team! (trust me, you’ll want to stick around for it)

But why focus on inspiration?

Because motivation fades, but inspiration fuels lasting change.

So right now, you’re asking me the question…

What can I do to inspire my folks?

Have you ever played with Lego blocks?

Let me share a story instead of answering with another question.

When I was 5, I received a Lego fire brigade set. The box showcased a magnificent fire engine with brave Lego firefighters manning the water cannons as if their tiny plastic lives depended on it. Behind it stood the fire station—a pristine building where these first responders could rest, restock, and prepare for their next mission.

Looking at that box, my young mind raced with possibilities: rescuing cats from trees, battling infernos in towering buildings, and becoming a hero who would save every life through acts of courage.

But do you know when the real magic happened? Spoiler: it wasn't during assembly.

It was when I held the instruction manual next to the set picture on the box.

Two elements, side by side:

• The LEGO box with the set picture (the dream)

• The assembly manual (the plan)

In our world, these translate to:

• A Vision – the aspirational picture of what we want to achieve

• A Strategy – the step-by-step plan to get there

Inspiration doesn’t just come from a compelling vision, but from having a clear, structured path to achieving it.

The Purpose—the big, yet crucial 'why?'

The Purpose answers the ‘Why?’
The Vision answers the ‘Where are we going?’

Everything begins with a team’s purpose—the foundation that fuels performance and growth.

• Why do we do what we do?

• Who are we and what do we stand for?

Think about it—your current position reflects your identity. Whether you’re a manager who thrives on leadership or an engineer who built trust through technical excellence, your role stems from who you are.

Teams must stand for something, too.

It took me two years and reading When They Win, You Win by Russ Laraway to fully grasp this. As a leader, it’s not just about defining the purpose—it’s about helping your team recognize their identity and shared future.

The magic happens when you heighten awareness of what makes each person successful—beyond business goals, into values, creativity, and perspectives.

The Vision—'where are we going?'

Once your team has established their belief system, they need to paint a picture of the future. This happens through creating the vision—imagine everyone picking up a brush, mixing colors on their palette, and making those first strokes together.

The first strokes might be messy, but the magic is in the act of creating together.

A strong vision answers:

• What hill are we climbing?

• It’s 2028—Our CEO is holding a party in our honor. What happened that caused him to throw this extremely expensive party?

While finding this answer isn't easy, the process is truly remarkable. I find myself eager to work with new teams just to experience that magical moment again!

Active participation in creating the vision statement lets everyone shape their future. I must emphasize participation because without it, the entire exercise is meaningless. The process must be inclusive, giving every team member a voice. Why? Because everyone wants to belong and contribute to group activities. Even those of us in technical roles, who typically focus on metrics and hard data, need to feel heard and valued.

The vision statement session benefits everyone involved. As a leader, you'll discover who's most passionate about the team's direction—and who isn't. It's particularly valuable when you're new to leading a group, offering insights into emerging leaders, team sentiment, and past experiences. You'll notice who actively engages and who stays quiet, providing valuable topics for future one-on-one discussions.

As an example, I'm sharing with you some of the vision statements:

1. Lego - A global force for Learning-through-Play.

2. LinkedIn - Create economic opportunity for every member of the global workforce.

3. Zoom - The AI-first work platform for human connection.

4. IKEA - To create a better everyday life for the many people.

The Strategy—roadmap allowing to know ’how do we get there?’

Once you have the purpose and the vision of the team, the last part of getting your team fired up is the creation of the strategy.

This part you do yourself.

And it’s my favorite one, because this is where you get to shine as a leader!

The strategy connects the ‘now’ with the future. **

Think of it as a roadmap—a structured plan that makes your vision achievable.

It’s incredibly rewarding when a team realizes, “Wait, we can actually make this happen!”

Sounds simple? Well, there’s one catch—it needs to be a good strategy. And that’s where most leaders go wrong…

Wait—I just realized that I’ve been writing this post for 4 hours… writing about the strategy will at least take me 2 hours, and I need to focus on my day job 😅

I promise that I will post an article about untangling the strategy and how it should be defined—deal?

Great—for now, read on how to run the Purpose and Vision workshop!

How to facilitate the Purpose and The Vision?

If you spot a gap in team identity, propose a workshop - it's a chance to show leadership skills.

You don't need to be in management to run a Purpose and Vision workshop. As any team member, you can lead this initiative to boost inspiration, which all managers will appreciate.

Let's get to the practical details—how do you organize and facilitate such a workshop?

1. Value Ideation (15 min + 1 hr discussion)

1. 15 minute reflection—every team member takes that time to themselves and writes down their values in the notes; to stimulate the creativity, use the questions:

   1. Why do we exist?

   2. Why do we matter?

   3. What fails to happen if we don’t show to work tomorrow?

2. 1 hour discussion—everyone presents their values, explaining what they mean. The goal is to align on a shared team identity. These are example values that a 6-person team can identify:

• Priya (Senior Software Engineer):

  • Craftsmanship – Writing clean, maintainable code.

  • Curiosity – Exploring new technologies and approaches.

  • Ownership – Taking initiative to solve problems.

• Alex (Product Manager):

  • User-first Thinking – Prioritizing the user experience.

  • Clarity – Ensuring simple, structured, and transparent communication.

  • Impact over Effort – Focusing on meaningful outcomes rather than just hard work.

• James (UX Designer):

  • Empathy – Understanding users' needs deeply.

  • Iterative Mindset – Designing through continuous feedback and improvement.

  • Collaboration – Working closely with engineers and PMs to build great products.

• Marta (DevOps Engineer):

  • Reliability – Ensuring systems are stable, scalable, and resilient.

  • Automation – Reducing toil through smart automation.

  • Security – Keeping systems and data safe.

• Elena (Engineering Manager):

  • Trust & Transparency – Creating an environment where people feel safe to speak up.

  • Growth Mindset – Encouraging learning and development.

  • Accountability – Holding myself and others responsible for commitments.

• Dan (Data Scientist):

  • Evidence-based Decisions – Using data to guide strategy and execution.

  • Integrity – Being honest about results and their limitations.

  • Exploration – Experimenting with new approaches to find better solutions.

Make sure that everyone has enough time to go through their values. This part is critical as you want the entire team to converge on a similar sense of purpose. That won’t be possible unless everyone actively participates in the session and speaks their mind.

2. Vision Ideation (15 min + 1h discussion)

For this part, you’ll at least need the entire second half of the 3-hour meeting. It will follow the exact same structure as in the previous part:

1. 15 minute reflection—everyone writes down their team vision in the notes; to stimulate creativity, use the question:

   1. What hill are we climbing?

   2. It’s 2028—our CEO is holding a party in our honor. What happened that caused them to throw this extremely expensive party?

2. 1 hour for sharing visions and noting them down. This full hour is essential - even experienced team members will get deeply engaged in the discussion.

This is a rough agenda for the meeting. Schedule it when everyone is at their best—ideally at the start of the workday when minds are fresh.

For distributed teams, you can split these two sessions across different days to reduce the energy demands of a single long meeting.

Final Thoughts: The Power of Purpose & Vision

This 3-hour workshop can transform a team’s alignment, motivation, and energy. It’s a simple yet incredibly effective way to inspire your team and create a sense of shared ownership.

If you’ve made it this far, here’s what I promised you at the beginning… If you want to run this workshop, I’ve got something for you!

Get these free resources:

⚡️A Slide Deck – A ready-to-use presentation with the workshop agenda and key talking points to help you facilitate the session.

🙋‍♂️ A Free Consultation – I’ll personally help you tailor the workshop to your team and share insights on making it work in your specific environment.

Interested? Drop a comment below or reply to this post, and I’ll send you the details!

This concludes Part 1 of how to motivate through Purpose, Vision, and Strategy. In Part 2, I'll explain how to craft an effective strategy.

Stay tuned!
- Leszek, From Teams To Titans

The challenges of leading from a distance

Managing remote teams is deceptively different from managing in-person ones. At first, I assumed leadership was leadership, regardless of location. But as I transitioned from managing colocated teams to leading people across time zones, I quickly realized that what worked in an office didn’t always translate remotely.

Suddenly, casual hallway conversations were gone. Visibility into my team’s day-to-day challenges was reduced. Feedback loops were slower, trust took longer to build, and coaching became a game of patience.

But the hardest part? If I wasn’t intentional about how I spent my time, structured my communication, and built trust, things quickly spiraled out of control.

Over time, I learned that leading a distributed team requires three key disciplines:

1. Tracking your time with intention - so you don’t get overwhelmed.

2. Practicing radical transparency - because trust isn’t built passively.

3. Creating structured coaching systems - to make up for the lack of real-time interactions.

Each of these lessons helped me become a better leader—and more importantly, helped my team thrive despite the distance.

Each of these lessons shaped the way I lead today, and they continue to serve me as I navigate the complexities of managing teams across different locations. Here’s what I learned.

1. Track your time or it will control you

You alone are responsible for how you spend your time. At the peak of my organization’s size, I managed 20 people across multiple time zones, and my workweek followed a familiar pattern:

• 9:00 AM: Catching up on overnight messages, emails, and document updates.

• Late morning to early afternoon: One-on-ones with local team members, making the most of our shared time zone.

I was driven by ambition—determined to build a world-class team. But in the process, I ended up working 13-hour days: checking in on everyone, staying updated, coaching, and firefighting.

It didn’t take long before I started dropping the ball. Quarterly surveys confirmed what I already felt—team members noticed that I had too much on my plate and needed help.

“I can handle this,” I told myself.

But no one asked me to work this way. No one told me to burn the midnight oil and micromanage everyone’s work.

I was doing this to myself.

A few months later, I finally admitted this to my boss. I’m lucky to have a great boss who immediately said:

“You need to tell me when help is needed.”

What struck me was how hard it is to gain perspective in the moment. When you’re deep in the work, tackling the next task always seems like the priority. It’s easy to lose sight of what actually matters.

How I regained control

To break free, I tracked every task in my calendar and color-coded it:

• How much time was I spending on one-on-one coaching?

• How much time went to backlog reviews and prioritization?

• Was I still contributing individually?

This exercise transformed my approach. My schedule stopped slipping through my fingers, and I could finally see where my time was going—and, more importantly, where it should go.

2. Transparency isn’t optional—it builds trust

As an electrical engineer who transitioned into software and later management, I initially believed leadership was a natural extension of technical expertise. But I quickly learned that being a great manager requires more than technical skills—it demands self-awareness, emotional intelligence, and the ability to connect with others.

When I worked in-person with my Zurich-based team, they saw how I operated daily—approachable, open, and transparent (or so I hope!). But in a remote environment, all of that disappears. People can’t see how you interact, read your body language, or fully understand who you are beyond the screen.

When transparency became critical

Early in my time with a new team that had just been assigned to me, I noticed signs of distrust. It wasn’t explicit, but their questions revealed uncertainty:

• “Are you planning any big changes in the next weeks?”

• “What’s your management style—hands-on or hands-off?”

• “Do you have background in computer vision?”

• “How do you know that you will be able to effectively lead our team?”

One moment, however, made the situation crystal clear.

During my introductory meeting with the team, one person openly pushed back against the reorganization, questioning both my role and the company’s credibility.

Right there, I knew I had very little time to fix this.

But I didn’t know what the solution was—yet.

How I turned it around

In a moment of doubt, I reminded myself to go back to first principles: transparency builds trust.

I introduced a 30-60-90 day milestone document—a structured plan to listen, learn, and lead effectively.

This simple tool provided:

• Clarity on my intentions—no hidden agendas.

• A structured way to engage the team—so they felt heard.

• A way to show who I am—not just as a manager, but as a person.

Over time, the resistance faded. The team saw that I wasn’t there to impose changes in secrecy, but rather that I was there to build with them, not against them.

Just as office interactions make a manager an open book, transparency in a remote environment must be intentional.

3. Coaching across time zones requires structure and discipline

Managing a distributed team is like being the captain of a slow-moving ship—you set a new course, go to sleep, and wake up to see the change in direction. But unlike steering a real ship, you can’t adjust in real time. You must trust your judgment, trust your team, and wait—sometimes for hours—to see whether your coaching and decisions take hold.

This delay became especially apparent when I took over a new team. I wanted to establish myself as a coach and mentor, while also fostering a culture of open feedback. But the 9-hour time difference between Zurich and the Bay Area made traditional coaching ineffective—I couldn’t observe how people applied my feedback, nor could I give real-time course corrections.

Now, think about how most people handle coaching:

• You give feedback in a 1:1.

• Your report acts on it.

• You observe, adjust, and reinforce as needed.

In an office, this cycle happens naturally. But in a remote team, I might not see the results for 16+ hours—or even until the next 1:1 meeting a week later. I needed a way to bridge that gap.

How I built a system for effective remote coaching

1. What’s the challenge? – The direct report documents the issue they are working through.

2. What actions are they taking? – A record of steps they’ve attempted or plan to take.

3. What’s the result? – Tracking outcomes and iterating based on what worked (or didn’t).

This was a game-changer. The document provided:

• A written history of coaching progress, making it easy to see growth over time.

• Clarity on next steps, ensuring feedback didn’t get lost between meetings.

• Asynchronous visibility, so I could review and provide input even when we weren’t online at the same time.

Seeing the horizon, even even you can’t control the ship

Just as a ship takes time to change course, you can’t control how quickly someone applies coaching. But what you can do is enhance their vision of the horizon—helping them see their growth and progress over time.

To reinforce this, I also started documenting feedback—both positive and constructive—for each direct report. Over time, this created a visible timeline of their growth and the challenges they had overcome.

In the end, remote coaching isn’t about being present in every moment—it’s about providing the right structure so that your presence is still felt, even when you’re not in the room.

Remote leadership is an intentional practice

Managing remote teams isn’t about replicating office dynamics online. It requires a different mindset and skill set.

• Without tracking your time, work expands endlessly, leaving you overwhelmed.

• Without transparency, trust erodes, leaving teams uncertain and disengaged.

• Without structured coaching, growth becomes inconsistent, leaving employees without the support they need.

Remote work doesn’t naturally foster alignment, connection, or clarity. You have to build them intentionally.

In the end, I believe that the best remote leaders not only adapt to the challenges of distance, but they embrace them and use them to their advantage—by creating systems that allow people to work effectively, no matter where they are.

Over the last ten years in Switzerland, I’ve worked in international environments collaborating with Swiss, American, and global teams across various industries. While many workplaces pride themselves on being international, the underlying cultural DNA still shapes how work gets done.

Switzerland, known for precision, structure, and risk-averse decision-making, fosters a workplace where process matters as much as outcomes. In contrast, American companies, particularly in tech, thrive on speed, iteration, and rapid decision-making, embracing calculated risk as a pathway to innovation.

Having navigated both worlds, I’ve experienced firsthand how these differences play out in everything from meetings and communication styles to leadership dynamics and decision-making. While both cultures pursue excellence, their approach to getting there couldn’t be further apart.

This fictionalized story—based on real experiences—explores these contrasts through two companies:

1. 🇺🇸 HustleTech, Inc. – A Silicon Valley startup that thrives on fast iteration, bold decision-making, and a flat, feedback-driven culture.

2. 🇨🇭 Helvetic Solutions AG – A Swiss tech firm built on methodical decision-making, structured hierarchy, and meticulous execution.

Both are at the cutting edge of technological innovation, yet their paths couldn’t be more different.

Communication Culture

🇺🇸 Prioritizing Flexibility

Tyler, head of engineering wants everyone to be present before the presentation can start. At HustleTech, the workday starts at 10:00 am with a presentation on what client they should partner with. By 10:03 am, most team members are online, already exchanging weekend stories. When Jake, the last to arrive, joins the call at 10:07 am, everyone is finally ready to give status updates. This could've been a quick message from each team member on the Slack channel, but hey—collaboration!

🇨🇭 Prioritizing Punctuality

Matthias, a senior director of technology, insists on starting the presentation on time. In Swiss culture, arriving late to a meeting is a no-go. The workday at Helvetic Solutions begins at 8:00 am, and the client partnership meeting starts at 9:00 am sharp. In fact, everyone is seated in the room by 8:58, with Simone still finishing the last bites of his breakfast Gipfeli 🥐, but never missing a beat in the structured environment.

"These meetings always start punctually," says Matthias. "Let's proceed!".

And so both companies begin their Monday strategic meeting, with Tyler favoring flexbility and Matthias opting for efficiency. Both of the approaches have their merits—how will the presentation unravel?

🇺🇸 Presenting Summary First

Tyler begins his presentation with a clear summary, then gradually expands on his reasoning to support his decision.

"Prioritize one client-champion over multiple less invested ones!" declares the first slide of Tyler's presentation. This summary is delivered with resounding confidence, prominently displayed on the slide.

"This is the direction we should take over anything else," says the director leading the meeting.

"Love it!" exclaims another participant.

Afterward, Tyler explains how the high sales margins of pilot projects failed to bring the company the success he had envisioned. He presents various insights from his team showing why betting big on partnering with a single "champion" client would put them on the fast track to success—despite lack of immediate returns—rather than pursuing multiple one-off pilot projects.

🇨🇭 Presenting Reasoning First

Matthias starts with providing the wider context of where his division is at. He consistently builds clarity and provides insights, surely converging to his main proposal.

"We've analyzed all options," explains Matthias. "None of our pilot clients advanced to our premium offerings." He presents analytics for client conversion in emerging tech markets with supporting case studies. He emphasizes the importance of proving success before the upcoming financial review. With participants anticipating his conclusion, he summarizes:

"For long-term success, we need a partner that will help us break through the market and attract investors—specifically an SME that's as hungry for recognition as we are."

While HustleTech debates the decision with the summary given up front, Helvetic Solutions arrives at the same conclusion not before presenting the investigated avenues, ensuring that every piece of data supports the strategy before it’s even proposed. Different approaches, same goal—but how does the team actually get to the conclusion?

🇺🇸 Bold Statements

Tyler runs a fast-paced, interrupt-driven meeting filled with strong opinions. Everyone is encouraged to participate in a "messy" discussion, even if their arguments aren't polished.

"We should scrap half of our leads in the pipeline," says Mark, a colleague from the engineering team, "and create a shortlist of those with whom we can build tighter partnerships. It will boost our growth 10-fold in the long run." This triggers an immediate discussion. Some voice their concern:

"That's bold—how do we know it's worth the risk?" asks one meeting participant.

"We don't have enough data yet," adds another.

"Who cares? We can test this fast!" retorts Mark.

🇨🇭Fact-Based Statements

Matthias and his team ensures that every point is meticulously justified before being presented. Jumping to a conclusion without first laying out the facts is seen as reckless. He spends the first 15 minutes of his presentation methodically laying out past conversion data before gently leading his audience toward the same conclusion.

“I’m not convinced about this” postulates Reto, senior accounting manager at the meeting. He pulls up the sales to-date figures and meticulously points out that the current trajectory has the company meeting the P&L margins for the year. With Matthias listening closely, a structured and synchronized exchange of ideas takes place. Everyone makes sure to back their argument with data.

“Your point is valid” agrees Matthias. “However given our financial projections and case studies of similar companies, we can infer that deepening our partnership with a single SME is the most statistically viable growth strategy.”

Both companies engage in debating the pros and cons of the proposed path. This is a very difficult decision to make—how does each type of discussion influence the likelihood of making the right decision?

🇺🇸 Fast, Iterative, and Decisive

The debate is heated but dynamic. At HustleTech, decision-making is a sport—rapid, assertive, and high-energy. Tyler watches as Mark and others exchange counterpoints, the conversation unfolding in bursts of challenge and defense. There’s no formal process—just a fast-moving flow of persuasion, questioning, and gut-driven calls.

Finally, Tyler makes the decision:

“Alright, let’s not waste time. I’m making the call. We’re going all-in on the Client-Champion strategy. Mark, work out the contract terms. Jake, get the customer success team aligned. Let’s get going right now.”

No need for a formal review, no deep consensus-building—the decision is made in the moment, and the team moves forward without looking back. The team disagrees and commits. But what if things go wrong? They’ll pivot. And that’s how HustleTech operates: execution first, refinement later.

🇨🇭 Deliberate, Consensus-Driven, and Risk-Averse

At Helvetic Solutions, the meeting does not end with an executive decree. The conversation continues in a structured, methodical flow, where each senior team member contributes their thoughts. Matthias, rather than asserting his own view, facilitates alignment:

“Let’s take a final round of inputs. Are there any additional concerns before we validate this decision?”

Reto, the senior accounting manager who initially questioned the revenue model, speaks first:

“I see the potential here, but I’d like to verify the financial implications before committing.”

Daniela, from operations, chimes in:

“From a resource allocation perspective, shifting to a single-client strategy will require recalibrating our delivery timelines. We need to assess the risk before finalizing.”

Rather than a heated back-and-forth, this discussion methodically progresses toward resolution, with each stakeholder offering a measured perspective.

Matthias nods, already expecting these responses.

“Understood. Let’s proceed as follows: We’ll conduct a final risk assessment with Finance and Operations. If the numbers align, we present our formal recommendation at next week’s executive committee meeting. If there are gaps, we reassess.”

A decision is not made in the room—it is structured into a process. The formal go-ahead will happen after collective validation, internal sign-offs, and a final executive endorsement.

Tyler believes that in a high-speed environment, the cost of inaction is higher than the cost of a wrong decision. On the other hand, at Helvetic Solutions, a decision is only as strong as the alignment behind it. A wrong decision is far more costly than a delayed one.

Leadership Model

🇺🇸 Frequent, Direct Feedback

Tyler's boss, Jake, is having a regular 1:1 meeting with Tyler and kicks it off with a casual chat about his weekend activities.

"Windsurfing… I haven't done that for a while!" exclaims Tyler who, as a surfer, finds this exciting. After this light-hearted exchange between surfer and windsurfer, boss and employee transition into the usual focus of their one-on-one conversations: feedback.

"Hey, your last report in the presentation wasn't as structured as usual," comments Jake.

"I know, you're right—I've been struggling with the uncertainty since we can't get the expected traction with existing clients," Tyler admits.

"How can you develop more self-awareness given the situation?" Jake asks as they continue their coaching session. Tyler views this candid feedback as a normal part of their meetings and an element of their fast-paced, feedback-driven culture.

🇨🇭Formalized, Diplomatic Feedback

Matthias' boss, Manuela provides feedback about his last series of reports during a dedicated quarterly feedback session. The meeting begins with a brief exchange of greetings, and at 13:01, like Swiss clockwork, Manuela and Matthias get straight to business.

"Your last three reports contained valuable insights, and I appreciate the direction you’re taking. To enhance their impact, refining the structure could improve clarity, making it easier for reviewers to follow the key takeaways and recommendations.” says Manuela.

“You’re right, that’s a fair point” he responds. This leaves him thinking: "She has a point, and why didn’t I think of all that sooner?"

The two companies' approaches to feedback differ drastically—HustleTech embraces immediacy while Helvetic Solutions maintains a more formal feedback culture. American employees are accustomed to frequent course corrections, whereas Swiss employees experience feedback as a structured, long-term process.

🇺🇸 Open-Door Leadership & Instant Access

At HustleTech, leadership is accessible, informal, and thrives on open discussion. Employees are encouraged to question decisions, offer new ideas, and even challenge senior leaders.

Midway through the week, Tyler posts a quick note in the company Slack channel:

“Leadership AMA tomorrow—ask me anything!”

The next day, questions come in:

1. “What’s our long-term vision for AI?”

2. “Why did we pivot away from the healthcare market?”

3. “Are we raising another funding round?”

Tyler answers every question, even the uncomfortable ones, in real time and with full transparency. At HustleTech, hierarchy is fluid, and a junior engineer can just as easily message the CEO as they can a teammate.

Even in meetings, executives are expected to be challenged:

“Tyler, I think we’re moving too fast on this. Have we really validated this market?”

“Good pushback. Let’s test it further.”

Leaders are expected to earn respect through results—not seniority alone.

🇨🇭 Leadership as Strategic Authority

At Helvetic Solutions, leadership is highly respected and operates through structured decision-making channels. Employees don’t casually drop suggestions in Slack, nor do they expect impromptu access to senior executives.

Instead of a Slack AMA, Matthias hosts a formal on-site all-hands meeting once a quarter. Questions are pre-submitted, screened, and carefully addressed to ensure alignment with the company’s messaging.

In meetings, direct challenges to leadership are rare. Instead, concerns are raised through the proper channels, often starting with a manager before escalating upward.

During a project review, Lukas, a mid-level manager, notices an issue with the proposed strategy. Instead of interrupting Matthias in the meeting, he follows the company’s structured process:

1. First, he gathers supporting data.

2. He presents his findings to his direct manager.

3. His manager escalates it to the leadership team for discussion.

Eventually, Matthias reviews the concern and responds in a later meeting, ensuring that the proposal is thoroughly analyzed before a decision is revisited.

Different Paths to the Same Goal

Despite their differences, both companies strive for excellence and innovation. Yet, their approach to getting there is fundamentally shaped by cultural expectations.

1. HustleTech moves fast, embraces direct feedback, and prioritizes execution over exhaustive planning. The cost of inaction is greater than the cost of a wrong decision.

2. Helvetic Solutions values precision, structured feedback, and consensus-driven decision-making. A wrong decision is worse than a delayed one.

Neither approach is inherently better—it all comes down to personal preference and work style.

Which work culture do you thrive in? Would you rather work in a fast-paced, high-energy environment or a structured, methodical one?

Ever wondered why the same productivity system that works brilliantly for one team completely flops for another? It’s not about the system, but rather about the people using it. No methodology succeeds without buy-in.

In this article, I’ll share how leaders can introduce productivity frameworks effectively—without undermining team dynamics or motivation.

How teams actually adopt productivity systems (Hint: not by the book)

Throughout my career, I’ve never been fully satisfied with how productivity systems were implemented.

As an individual contributor, I felt that processes were prioritized over people. As a manager, I observed that teams rarely followed the textbook implementation of these systems. Too often, choosing a productivity system came down to opinion rather than fact:

- “Look, Agile is all about keeping things flexible: short cycles, constant feedback, and adapting on the fly so we don’t waste months building the wrong thing!”

- “Nah, man, Lean is where it’s at—cut the crap, focus on what actually delivers value, and stop wasting time on pointless meetings and fluff!”

Let me be clear: I actively support teams in choosing processes that work for them, and there are many well-documented success stories of various approaches. However, I’ve learned that every team is unique. Just because a system worked elsewhere, does that mean it will work for your team?

A framework without buy-in is just bureaucracy

Adopting a new productivity system is just like adopting a new culture—everyone needs to be on board.

In my experience, no team was ever fully invested in implementing Scrum according to the official guide. Moreover, I've often observed Agile practices overshadowing open-mindedness and the discovery of better development methods. Instead, they tend to deteriorate into ego-driven ceremonies or become overly focused on following processes and tools.

After fifteen years working in industries from air logistic, through real estate analytics to augmented reality, I’ve realized one thing: success isn’t about process. Success is about people—what drives them, how they collaborate, and whether they truly believe in the system they’re asked to follow.

Why is this important? Because every team consists of individuals who think differently, use different tools, and have unique experiences. The dynamism and unpredictability of the real world shapes each person's distinct viewpoint. Leaders must recognize this when introducing any new process—after all, they're asking team members to embrace a methodology that will govern a third of their daily lives. It's akin to adopting a new belief system overnight. Success is impossible without first considering whether team members are invested in the change, believe in the system, or have been offered the chance to explore alternative frameworks.

Why do teams struggle with productivity systems?

Not identifying the desired outcome

Many teams adopt a process without clearly defining what success looks like. Is there focus on faster execution, better collaboration, or increased innovation? The right system depends on the goal.

All businesses strive for results, and high-performing teams are essential to achieving these goals. This principle should extend to defining the how of a team's daily work. Too often, I've seen processes implemented simply because they're trendy or because other companies are using them. While adopting new approaches shows leadership's commitment to industry best practices, implementation delivers little value unless the expected results are clearly defined and monitored.

I recall an experience when being the most senior engineer on a team, I wasn't entirely clear why I was introducing Scrum. Was it to get organized? To create a platform for regular deliverable inspections? I wasn't sure. It’s not difficult to envision that that attempt to adopt textbook Scrum didn’t go well.

💡Learning #1: always start by sharing the business challenge you're trying to solve. This clarity will help team members better understand both the current situation and your desired outcomes. It will greatly increase the chance for a positive change in the team system.

Overlooking the human in the team

A great system on paper can destroy motivation if it clashes with how people work best. Engineers and researchers resist top-down mandates but thrive under autonomy-driven structures.

The best managers create conditions where teams shape their own systems. Leadership is about fostering ownership, not about enforcing compliance. Establishing open communication isn't a sign of weakness—it's an opportunity to build trust, enhance everyone's problem-solving abilities, and foster a culture that welcomes diverse opinions and viewpoints. In none of the heated team debates that I’ve participated in, have I heard others say “I liked being proven wrong by the boss” yet I’ve heard the appreciation “I liked being heard by the boss”.

I once witnessed a senior executive attempt to impose cultural values on the engineering team without any prior consultation. When presented with these new values, the team unanimously resisted. No one appreciated how these expectations were communicated and the town-hall on which this was presented imploded spectacularly. This approach failed to build trust or demonstrate effective leadership. As a result, the engineering team never adopted these values and became less aligned with the executive's vision.

I’ve felt the effects of such mistake on my skin, too. As a manager, I once failed to gauge the team’s collective sentiment before introducing a change. To improve my team's goal-setting and execution capabilities, I decided to implement individual-level OKRs. This backfired tremendously because I failed to articulate why increasing team efficiency mattered. Most team members rejected the approach, and it became a failure—the change never achieved its desired outcome, and I wasted enormous energy trying to convince people to adopt an idea that never gained traction. Even today I believe implementing individual-level OKRs was the right decision, but my failure to effectively know my team doomed the initiative.

💡Learning #2: don’t make an executive decision, but make a proposal for the change subject to discussion. There is always a better way to solve a particular problem—going back to the distinct viewpoints that there are in a team, you can harness it as a force multiplier for finding ways of addressing a problem that may very well be much more efficient than your idea.

Failing to inspect for performance

A process is a hypothesis—it must be tested and adapted. Research and maintenance teams require continuous evaluation to ensure the system serves them rather than constrains them.

Introducing a change to a productivity system without planning for later inspection is a red flag. Every process change must be revisited and evaluated against underlying metrics. How else can we determine if the change has been beneficial? As mentioned earlier, adopting a new productivity system mirrors adopting a new culture—but unlike culture, it can be measured. Having concrete data points proves especially persuasive when convincing technically minded individuals in tech teams.

One of my previous bosses openly shared the metrics he used to evaluate productivity, which I found great. This gave me a clear understanding of how my work quality was reflected in the statistics. With this insight, I realized I could make his job easier by submitting smaller code changes that were easier to review. Truly a win-win situation. I could submit changes more frequently, and his other direct reports became more agile since they had smaller chunks of code to review!

💡Learning #3: What gets measured gets managed. Before introducing an organizational change:

1. Ask yourself "What is the purpose of this change?";

2. Choose one key metric to track the impact of the process change;

3. Schedule a specific date to review the results with your team.

This metric will provide concrete evidence for your team to either maintain or reverse the process change.

The manager as navigator of individualism

High-performing teams thrive not because of the process, but because of their ability to adapt, challenge, and improve it.

And that’s what great leadership is all about: not enforcing a system, but helping a team build their own.

Imagine two engineers. Both are technically excellent, but one consistently gets promoted while the other stagnates. Why? Because performance isn’t just about coding—it’s about demonstrating value, fitting company culture, and working smarter with automation. Master these three areas, and you’ll position yourself ahead of the curve.

In early 2025, many companies laid off thousands of employees amid sweeping cultural changes across the tech industry. These changes included the elimination or rebranding of diversity and inclusion programs, alongside mass layoffs justified as making companies "leaner" and "more prepared for the future." Adding fuel to the fire, prominent tech leaders have made numerous statements predicting that AI solutions will automate away mid-level software engineering roles. Make no mistake - the technological landscape is rapidly changing, fostering new workplace cultures that are replacing the status quo. This situation has led to heightened anxiety and stress. As people witness both the potential and risks of AI automation, many are questioning which career paths remain viable for their future.

Demonstrating the right performance in today’s uncertain world will greatly increase our chances of having a meaningful, fulfilling career. In this article, based on my insider perspective I’ll give you a practical guide to ensure you don’t just survive but thrive.

Create value beyond technology

Why this matters: senior leaders prioritize profitability, efficiency, and strategic impact. Being "technically great" is not enough. Creating business value will become increasingly vital for talent retention during performance reviews.

Taking action: strengthen your outcome-based approach by asking yourself these weekly questions:

1. What metric does my work influence?

2. How will my work create value for those around me?

3. Can I explain my impact in a way leadership cares about?

Based on my experience attending performance review meetings with organizational leaders, I've noticed a growing emphasis on evaluating tangible work outcomes. Employees who receive higher scores consistently show deep awareness of the business metrics they influence. More notably, there's diminishing tolerance for keeping staff who cannot demonstrate clear evidence of their productivity and output. By taking outcomes and desired outcomes of our work into consideration we strengthen the results as part of our performance equation.

When working on system performance improvements, be specific about quantifying the impact. Rather than saying "we reduced query latency," which is vague, it's more compelling to say "we improved checkout conversion by 5%." In this case, the reduced query latency directly improves the conversion rate at the final stage of the sales funnel, ultimately increasing company revenue. Also, it clearly shows thinking past the underlying technology and underlines the awareness of increasing revenue, or improving user engagement. In his blog article, “The Developing Dev” Ryan Peterman provides a great example such emphasis of technology as an enabler of business goals!

For examples of a results-oriented approach in daily work and how to demonstrate awareness of organizational goals, see the article that I wrote on the topic (link below).

Align yourself with company culture

Why this matters: cultural alignment is becoming a key retention factor. In an era of high performance demands, tech leaders aren’t just hiring skills, they’re hiring people who fit their vision of productivity and work ethic.

Taking action: regularly evaluate how well you align with company values and plan career moves before misalignment becomes problematic. Ask yourself these key questions:

1. Do I feel energized or drained when coming to work?

2. Does the company's vision truly inspire me?

3. Does the work environment fuel my motivation?

Manager feedback
Your manager should be your primary source of feedback about your alignment with company values. This feedback belongs in regular one-on-one meetings where you discuss performance, career development, and your role within the team's direction. By combining self-reflection with your manager's honest feedback, you'll gain a clear understanding of how well you fit the company's ideal of a model collaborator.

Pay attention to who gets promoted
Moreover, observe who gets promoted in your company—what behaviors do they share? When promoting someone, the company sends a clear message: "This person exemplifies our values" and "We reward this type of performance, mindset, and behavior." Use these promotions as your guide for better cultural alignment.

Speak the leadership language
Additionally, adopt the communication style of leadership. For example, if your company emphasizes product quality through automation, use phrases like "winning through automation" in your discussions. In your communications, highlight how you're leveraging automation to help your team succeed.

High performance is in demand more than ever. Mark Zuckerberg has expressed wanting more "masculine energy" at Meta, while Elon Musk demands his employees be "hardcore" and maintain a high work pace. These aren't just soundbites—they dictate hiring, promotions, and layoffs. If you're in an environment that prioritizes intense work culture, your survival depends on embracing that mindset or finding a better fit elsewhere. These tech leaders seek unwavering commitment from their workforce—a stance reflected in their hiring and firing practices. Following the Twitter acquisition in November 2022, Musk fired at least 3,700 employees who didn't align with X.com's new cultural direction. More recently, Meta laid off over 3,600 employees after Zuckerberg warned of an "intense year" ahead. These big companies aren't alone—in January and February 2025, 55 tech companies have laid off more than 13,000 employees! Organizations of all sizes now seek stronger alignment between their talent and their standards for collaboration, communication, and workplace mindset. This makes it essential for workers to thoroughly understand their company's culture, values, and collaboration standards. The stakes are high as even high performers at Meta have been let go, suggesting that strong performance alone isn't enough to ensure job security when compared to cultural alignment, which companies now appear to value at a premium.

Embrace automation and technology integration

Why this matters: AI isn’t replacing engineers, it’s making them exponentially more productive. Those who can integrate AI tools into their workflow will stand out, while those who resist risk being left behind.

Taking action: leverage automation tools to increase your output within the same amount of time.

Throughout history, technological revolutions have transformed how we work and live. The Industrial Revolution brought massive changes - from manufacturing advances to improved healthcare and education. This led to profound social shifts, including the rise of wage labor, public education, and consumer culture. Today, we're at a similar turning point with AI, which acts as a powerful force multiplier for achieving outcomes faster. The industrial revolution didn’t eliminate workers—it turned them into operators of machines that amplified their output. Today, AI does the same: it’s the modern equivalent of steam engines and assembly lines, allowing professionals to accomplish exponentially more. While this article isn’t meant to provide hands-on guidance on how to apply the tooling, I’d like to provide you some examples of how to achieve higher yield in different areas by relying on automation.

Programming

Use AI-based tools like Copilot and Vercel v0 to rapidly generate ready applications. In the well-known blog throughout the tech industry, The Pragmatic Engineer, Gergely Orosh gives a good situational overview of how AI can be used to jump-start application building bootstrap the first working version of a prototype!

Writing & editing

Ethan Mollick writes about integrating AI into his daily routines, showcasing its effectiveness in tasks ranging from text formatting to proposal writing. I recommend visiting his blog One Useful Thing.

Research, information synthesis

Executives from firms like Deloitte, EY, KPMG, McKinsey, and PwC have shared insights on effectively utilizing AI. This article tells how they employ AI tools for research, trend analysis, drafting communications, and automating tasks. For instance, Dan Priest at PwC uses AI for labor productivity research and policy writing, while Jim Rowan at Deloitte relies on AI for drafting newsletters. These leaders highlight the importance of clear, contextual prompts and view AI as a collaborative partner in enhancing productivity.

The path forward: thriving in the industry of tomorrow

The reality of today’s tech landscape is brutally clear: companies are prioritizing business impact, cultural alignment, and automation-first mindsets. As the industry evolves, so must we.

So, what’s next? How do you not only survive but thrive in this new era?

Make business impact your north star

• Stop thinking about your work in isolation—connect it to revenue, cost efficiency, and customer success.

• Every task you take on should have a measurable business outcome.

Align with your company’s culture, or find one where you belong

• The most successful employees don’t just perform well—they fit well.

• Study who gets promoted, how leaders communicate, and what behaviors are rewarded.

Master automation to multiply your output

• AI isn’t a competitor—it’s an amplifier. The professionals who integrate AI tools will outperform those who don’t.

• Whether it’s coding, writing, or research, leverage AI-powered tools to achieve more in less time.

Sources

1. The Cut. Mark Zuckerberg thinks companies need ‘masculine energy’ (link)

2. Business Insider. Elon Musk has been preaching the value of 'hardcore' work to employees for over a decade, early Tesla emails show (link)

3. The Conversation. Elon Musk’s ‘hardcore’ management style: a case study in what not to do (link)

4. The Pragmatic Engineer. How developers are actually using AI (link)

5. Blog One Useful Thing (link)

6. Business Insider. AI execs at big consulting firms share their favorite prompts and how they use the technology (link)

When I started my first job, I believed excellent work alone would earn recognition in performance reviews. During my second year, I was stunned to receive only a "meets expectations" rating—I had no system to showcase my impact, and my new manager was unaware of my contributions. This experience taught me that performance reviews aren't just about your work but how effectively you present your value. Since then, I've developed a system that has helped me and my teams earn well-deserved recognition, promotions, and raises. Here’s what you need to know.

Keep track of what you did

Most managers don’t remember every contribution—it’s your job to document them.

List your top 3 achievements first. These should clearly demonstrate your value to both your immediate manager and other calibration managers, while being concise enough to quickly convey your impact.

💡 Tip: keep a running list in a simple Google Doc, Notion page, or spreadsheet to track achievements and their impact. Haven't kept such a document? Don't worry—you can mine your weekly, monthly, and quarterly team presentations or personal documents to reconstruct your deliverables and their business context. Most organizations also use work tracking software like JIRA—simply filter by your username to find your completed epics, tickets, and tasks!

Emphasize organizational impact

Show your business impact using this formula: Problem→Actions→Outcome.

• Problem: What challenge did the business face?

• Actions: What did you do to address it?

• Outcome: What measurable results did you achieve?

During yearly reviews, organizations assess each individual's contribution to the company's success. You don't need to be a manager to show how your work affects the bottom line. Even at entry level, understanding the broader business context catches reviewers' attention—these are the people steering the company. Also, make sure to quantify outcomes wherever possible—think % growth, time saved, costs reduced, etc.

This approach demonstrates professional maturity and builds trust. When you explain the initial motivation behind your actions and their results, you show that you consistently consider the company's needs in your decision-making. Consider the following examples:

Senior Marketing Specialist

Achievement: Increased Lead Generation Through Targeted Content Strategy

Problem: Lead generation was declining, with low engagement from key target audiences on LinkedIn, Google Ads, and email marketing campaigns. Our content wasn't connecting with decision-makers in target industries, resulting in a 15% drop in conversion rates.

Actions Taken: Analyzed audience behavior and campaign data to identify content gaps. Created a targeted content strategy with SEO-optimized blog posts, LinkedIn thought leadership articles, and personalized email sequences. Partnered with the sales team to address specific customer pain points.

Outcome: Boosted website traffic by 40%, improved LinkedIn engagement by 30%, and increased qualified leads by 25% within three months, strengthening our sales pipeline.

Intermediate Project Manager

Achievement: Delivered the "Nova CRM Integration" Project Ahead of Schedule

Problem: The "Nova CRM Integration" project faced deadline risks due to scope creep, misaligned stakeholder expectations, and inefficient resource allocation—putting a key client contract at risk.

Actions Taken: Realigned project scope with stakeholders, streamlined requirements, and optimized resource planning. Implemented weekly Agile stand-ups and a Kanban board to enhance team communication and progress tracking. Maintained proactive risk management through bi-weekly stakeholder check-ins.

Outcome: Completed the project two weeks early with 15% cost savings. The successful integration led to improved client satisfaction and a $500K renewal contract.

💡 Tip: Review your weekly, monthly, and quarterly presentations or documents to recall your team's deliverables and understand the broader business context of your contributions.

Differentiate your achievements

The key to an effective achievements list is showing how your work differentiates you from your peers. Help the reviewer understand exactly what made your contributions stand out. Was it delivering higher quality work, or perhaps creating an exceptional customer experience? Focus on specific aspects that distinguish you from your colleagues. For example, if your team's goal was to reduce operational costs, highlight the innovative approaches you took to improve efficiency in ways that set you apart.

Principal Full Stack Engineer

Achievement: Cloud Migration Cuts Operational Costs

Problem: Our SaaS platform ran on outdated on-premises infrastructure with poor scalability and high maintenance costs. Monthly infrastructure spending exceeded our budget by 20%.

Actions Taken: After analyzing various cloud solutions, I led the migration to AWS using serverless architecture with AWS Lambda, DynamoDB, and S3. I designed a phased migration strategy, refactored microservices for serverless compatibility, and implemented auto-scaling with cost monitoring tools through AWS Cost Explorer.

Outcome: The migration reduced infrastructure costs by 40% annually. The new system improved reliability, cut deployment times by 30%, and enabled scalable growth without added overhead.

Rather than focusing on quick fixes, this engineer implemented a strategic long-term solution. The migration eliminated on-premises infrastructure that had required two engineers to maintain. These engineers were then reassigned to a revenue-generating project elsewhere in the company. Additionally, this innovative approach leveraged cloud infrastructure to enhance the platform's overall reliability and stability.

Unsubstantiated success = no success

Be prepared to enter the review process with a rock-solid foundation of evidence and documentation to support your work output:

1. Save emails, presentations, reports, and project artifacts that showcase your impact and contributions throughout the year.

2. Include specific metrics and data: Use concrete numbers, percentages, and measurable outcomes to demonstrate your success (e.g., cost savings, efficiency gains, customer satisfaction scores).

3. Build a portfolio: Organize your work samples, project deliverables, and achievements in an easily presentable format for review discussions.

4. Document process improvements: Maintain records of enhanced workflows, procedures, or systems, complete with before-and-after comparisons.

5. Track timeline adherence: Preserve project schedules and milestones that demonstrate your ability to deliver on time or ahead of schedule.

💡 Tip: compile all documents, slides, screenshots, and reports in a dedicated Google Drive (or whatever document database that’s used at your company) that's visible to the entire organization. This ensures unobstructed access to evidence during reviews. Follow your company's preferred method for sharing documents and make sure the data is easily accessible—after all, evidence has no value if it can't be seen.

360° feedback is everything

When an organization promotes someone, they're essentially saying, "be more like this person." Companies prioritize promoting top performers who are also excellent collaborators. They closely evaluate your communication style, pro-activeness, and ability to work well with others. I've seen firsthand how calibration sessions can remove candidates from promotion consideration simply because their collaboration skills didn't match the high standards set by their peers.

Collaborate with your manager to identify the most relevant people to provide your 360° feedback. Make sure to highlight specific projects you've worked on to receive detailed, meaningful feedback. If you've worked with multiple stakeholders throughout the year, ask your boss to reach out to them for feedback on your behalf. Your boss should send out a somewhat similar message:

Dear [stakeholder name],

I hope this message finds you well. As part of our talent cycle process, I’m gathering 360° feedback for [your name].

Since your team collaborated with [your name] on [project name], I’d greatly appreciate it if you could share your observations on his/her performance—specifically regarding collaboration, impact on the project, and any areas where he/she excelled or could grow.

Thank you in advance for your time and support.

Turning preparation into performance

Mastering your yearly performance review isn’t just about listing achievements, but about telling a compelling story of your impact, growth, and potential. By proactively tracking your accomplishments, framing them within the broader business context, and substantiating them with evidence, you position yourself as a high-performing professional who not only delivers results but also drives meaningful change.

Your performance review is a chance to take control of your career trajectory. With the right preparation, you can turn it into an opportunity for growth, recognition, and advancement. Start today: Open a doc, list your top three achievements, and craft your Problem → Actions → Outcome stories. Your future self will thank you.

For DeepSeek, these constraints—combined with urgency and ambition—catapulted the company into the AI stratosphere, putting it in direct competition with giants like OpenAI and Anthropic. The USA imposed restrictions on China's access to advanced semiconductors, particularly GPUs used to train AI models. In response to the October 2023 sanctions, Nvidia developed the H800 specifically for the Chinese market. The situation worsened a year later when additional US semiconductor restrictions effectively banned the export of even these downgraded graphics cards to China. These measures placed Chinese startups at a significant disadvantage compared to their American counterparts, who faced only financial constraints in accessing cutting-edge GPUs. As a result, DeepSeek's researchers and engineers had to work with a limited fleet of graphics cards, forcing them to develop ingenious and unconventional approaches to achieve their goals.

This analysis shows how their unconventional approach to sourcing talent, assignments centered on staff strengths, and strategic foresight set DeepSeek up for unprecedented success in the AI domain.

No experience—no problem

DeepSeek's hiring strategy is based on two simple rules: a hard "no" to anyone with more than 8 years of experience, and for applicants with 5-8 years of experience, they must demonstrate truly elite performance during interviews. Real innovation comes not from preconceived notions of problem-solving, but from pure interest and curiosity in understanding the true nature of assignments.

DeepSeek's R&D thrives on university graduates and early-career professionals. Notably, many individuals behind the breakthrough model R1 came from fields like physics and mathematics rather than computer science. The company has turned the traditional talent-finding approach—based on seniority and industry experience—upside down, favoring individuals unburdened by repetitive corporate work. As Liang Wenfeng, CEO and founder of the company, puts it: "What we need are people who are extremely passionate about technology, not people who are used to finding answers based on experience."

While many companies recognize that junior hires often think more creatively, DeepSeek elevated this concept into a core principle—making it the foundation of their innovative culture.

Flat, goal-centered structure

The employees behind the world's hottest LLM have the confidence to maximize their impact, supported by peers who recognize each other's strengths. Assignment structures are tailored around everyone's specialized skills. Rather than having teams with assigned managers, they organize around specific goals or problems to solve. In these groups, individuals can push boundaries while applying their unique strengths. Goal groups have no fixed headcount—instead, they are staffed with individuals who can make the biggest impact on the problem at hand.

This approach differs from the traditional model where managers dictate roadmaps and maintain exclusive oversight of team activities. It aligns with the 'betting' concept in the ShapeUp methodology—teams commit to specific outcomes within defined time periods and scope. The decentralized structure encourages proactive communication, particularly when solutions aren't immediately apparent. Through team transparency, DeepSeek creates an environment where teams learn from and support each other when facing obstacles.

Pulling on the rope together

Every individual, regardless of their background or experience level, possesses the innate capacity to generate groundbreaking ideas that can revolutionize the company's approach to problem-solving. Moreover, the company maintains a deliberately flat organizational structure where all employees share the title "Member of the Technical Staff" - there are no hierarchical distinctions, senior titles, or experience-based levels assigned to any team member.

Is DeepSeek building the future tech workplace?

The company’s culture isn’t just an experiment in efficiency—it’s a masterclass in organizational function. By rejecting conventional wisdom on talent, structure, and leadership, the company has demonstrated that radical approaches can lead to groundbreaking results.

If DeepSeek continues to succeed, its “hierarchy-free, constraint-driven, interdisciplinary-first” model could inspire the next wave of AI startups to prioritize ingenuity over brute force. However, whether this model can scale beyond a single breakthrough remains the biggest open question.

Will DeepSeek’s radical structure redefine AI workplaces, or is it a product of unique constraints that won’t last? Time will tell—but for now, it stands as one of the boldest organizational experiments in the AI industry.

Sources

1. The Guardian. Who is behind DeepSeek and how did it achieve its AI Sputnik moment? (2025) (link)

2. 36Kr. DeepSeek's employment philosophy: top students, young people, no rat races (2025) (link)

3. Weixin AI Blog. DeepSeek’s talent perspective: no KPIs, flat hierarchy, no rat races (2025) (link)

Stepping into a management role is exciting and offers a brand new path for making an impact across your company. Like in every discipline, the beginnings are not easy and it’s not always clear how one should navigate surfacing challenges.

Let me share my recollection of my early days as an engineering manager—how I experienced this shift in reality and the major challenges I faced. For each challenge, I'll highlight key leadership aspects that every boss should keep in mind, whether they're just starting their managerial journey or are seasoned leaders.

Trust: The Foundation of Leadership

Trust - assured reliance on the character, ability, strength, or truth of someone or something. [1]

Fostering trust among your team members, stakeholders will be fundamental in creating your success as a leader. Trust is necessary to build the right communication and collaboration culture. An effective leader must acknowledge that and give the right amount attention to learning each individual’s perspective on preferred ways of contributing, their view on team dynamics and their career aspirations.

In his influential book The Five Dysfunctions of a Team, Patrick Lencioni identifies trust as the cornerstone of team cohesion. By building trust, teams can minimize interpersonal conflict and create a supportive, collaborative work environment that drives success.

Building trust has not only helped lead an innovative and productive team but has given me an opportunity to connect with people on a more personal level, providing a perspective on their personalities, experiences and opinions. They allowed me to form an understanding about a person’s motivations and preferences, strengthening the relationship between introducing a team change and observing a positive response.

Avoid Micromanagement

Micromanagement — the direct management of a project, etc. to an excessive degree, with too much attention to detail and insufficient delegation. [2]

When I first became a manager, I stuck to what I knew best: programming. I believed that by personally maintaining high-quality code, I could ensure success. But this approach came at a cost—I was stifling my team’s growth. Team members were hesitant to take initiative and our strategic priorities suffered. Overcommitting to individual contributions was leaving consequences to the well-being of the team:

1. Slower discovery of team members’ individual strengths and motivations;

2. Negligence of product vision and blunted strategic awareness;

3. Demoralization that I’m “in their kitchen”.

Through feedback I was made aware of that I’m not managing—but rather micromanaging, one of the all-time dreaded qualities of a boss.

Let’s not be afraid to use this word where applicable—exercising excessive control over product changes will take away growth opportunities for the team individuals. Research by Deci and Ryan (2000) [3] on self-determination theory highlights that such control undermines intrinsic motivation by limiting autonomy, a critical driver of creativity and engagement. Instead of fostering innovation, micromanagement discourages initiative and reduces overall well-being within the team.

To grow as a leader, I had to shift my mindset. I slowly started encouraging my team to experiment and solve problems their own way. This not only empowered them but also accelerated their learning and boosted morale. By releasing my grips on the “hows” of product contributions, I have witnessed a speed up the learning process of the group and it has paid significant dividends.

Embrace Continuous Learning

Continuous learning is not just about picking up new skills—it’s about constantly evaluating and refining how you lead. Early in my management journey, I struggled to delegate effectively. Journaling became my go-to tool for self-reflection. By reviewing my decisions and communication style daily, I identified habits that were holding me back. For example, I noticed that I avoided delegating certain tasks out of fear they wouldn’t be done ‘my way,’ which was slowing team progress.

To efficiently learn the essentials on the job, self-reflecting and open-mindedness are must-have qualities. New managers face a steep learning curve. The 2015 Gallup report State of the American Manager [4] reveals that most companies, including those in tech, promote individuals based on technical expertise or tenure rather than formal training in management. This leaves many new leaders unprepared for the nuanced challenges of the role.

Having said that, there’s no step-by-step guide for navigating everyday managerial situations. To learn effectively on the job, self-reflection and open-mindedness are essential. Here are a few ways to prioritize learning:

1. Seek mentorship from a trusted colleague or someone in your professional network.

2. Journal regularly to reflect on your decisions, challenges, and interactions.

3. Proactively ask for feedback from your team and peers.

4. Explore coaching or therapy to better understand yourself and your leadership style.

These are just starting points, but each person’s learning journey is unique. So, let me leave you with a question to reflect on: “Under what conditions do I learn best?”