Summary

In this episode, Andy sits down with Johan Roos, professor and executive advisor at Hult International Business School, Executive Director of the Peter Drucker Society Europe, and co-inventor of the LEGO® Serious Play® method. Johan is the author of Human Magic: Leading with Wisdom in an Age of Algorithms, and he has spent decades studying how people think, create, decide, and lead together.

Andy and Johan explore the two paths Johan calls erosion and amplification, starting with a question Andy has been wrestling with as he hands more of his manual driving over to Tesla's self-driving. You'll hear what an eroding project manager actually looks like day-to-day, why practical wisdom matters when the analytically optimal answer is not the wisest one, and how AI feeds one kind of curiosity, the laser, while starving another, the radar. Johan also explains the difference between becoming an AI concierge and practicing what he calls professional citizenship, and he shares what parents can do to help their kids hold onto the messy, hands-on curiosity that machines cannot supply.

If you're looking for a thoughtful, hopeful way to use AI without surrendering your judgment, this episode is for you!

Sound Bites

• "Almost every good idea I've had was not in front of the screen."
• "I know what to do, but I've stopped understanding why.".... The eroding project management can no longer explain the why."
• "So in a sense, they argue that the better the system, the stronger pull down the erosion curve."
• "So the message is really when the machines are taking over more and more of some of these subtle, very valuable capabilities we have, we have to climb the value creation ladder."
• "So a complexity is exactly where our wisdom gets exposed."
• "So every metric said fantastic, but nobody asked why, and is this right?"
• "If AI can write a document that is important to you, the document was never where the value lived."
• "But we just have to be careful to not sort of delegate too much of our brain power and sort of erode our jelly bean."
• "When you lean back and you haven't struggled enough, you may be super smart and, and the best brilliant individual in the world, but, you know, friction is good."
• "Are you able to argue for your case without holding on to the AI-produced slide?"
• "Protect the wandering curiosity, unstructured exploration, questions with no immediate payoff, the freedom to follow something nowhere in particular."

Chapters

• 00:00 Introduction
• 02:35 Start of Interview
• 02:44 Growing Up Inquisitive and the Power of "Because"
• 06:04 Self-Driving Cars, GPS, and the Erosion of Our Abilities
• 10:31 Becoming an Active Supervisor Instead of a Passive Passenger
• 13:55 What an Eroding Project Manager Looks Like Day to Day
• 18:52 When the Optimal Answer Is Not the Wisest One
• 22:03 Intuition, Gut Feel, and When Something Does Not Smell Right
• 25:54 The Laser and the Radar: Two Kinds of Curiosity
• 27:52 Creating Independently Before Consulting AI
• 30:44 What Happens in the AI-Free Time
• 35:18 Is It Intuition or Is It Ego?
• 37:48 Turning the Models Loose on His Own Book
• 40:00 Asking AI to Be Brutally Honest
• 41:02 AI Concierge Versus Professional Citizenship
• 45:51 Advice for Parents Raising Kids in the Age of AI
• 49:26 Staying Human: Theater, Walks, and Getting Your Hands Dirty
• 50:44 End of Interview
• 51:15 Andy Comments After the Interview
• 54:46 Outtakes

Learn More

You can learn more about Johan and his work at humanmagic.one.

For more learning on this topic, check out:

• Episode 500 with Steve Brown. Steve is a former Google DeepMind futurist, and he has a unique perspective on where we've been and where we're going with AI.
• Episode 479 with Matt Mong. Matt shares his take on the AI skills we need to stay relevant in the years to come.
• Episode 463 with Faisal Hoque. Faisal helps us go beyond the fear and the hype around AI to a helpful way to think about the human-AI relationship.

Chat with PMeLa

You can chat directly with PMeLa, the podcast's AI persona, to get episode recommendations and answers to your project management and leadership questions. Visit PeopleAndProjectsPodcast.com/PMeLa to chat with her.

Join Us for LEAD52

I know you want to be a more confident leader–that's why you listen to this podcast. LEAD52 is a global community of people like you who are committed to transforming their ability to lead and deliver. It's 52 weeks of leadership learning, delivered right to your inbox, taking less than 5 minutes a week. And it's all for free. Learn more and sign up at GetLEAD52.com. Thanks!

Thank you for joining me for this episode of The People and Projects Podcast!

Talent Triangle: Business Acumen

Topics: Leadership, Project Management, Artificial Intelligence, Practical Wisdom, Curiosity, Critical Thinking, Creativity, Decision Making, Judgment, Professional Development, Human Skills, Parenting

The following music was used for this episode:

Music: Echo by Alexander Nakarada
License (CC BY 4.0): https://filmmusic.io/standard-license

Music: Chillhouse by Frank Schroeter
License (CC BY 4.0): https://filmmusic.io/standard-license

The Flutter State Dilemma

Every Flutter developer eventually wrestles with state management granularity:

"How do I balance developer ergonomics against architectural rigor? When is a simple reactive primitive sufficient, and when do I truly need a structured, event-driven state container?"

For years, developers have swung between two frustrating extremes:

1. The Over-Engineering Trap: Creating multiple event classes, sealed hierarchies, and asynchronous stream plumbing just to toggle a boolean accordion or expand a card.
2. The Spaghetti Trap: Relying entirely on untracked, ad-hoc mutable state for complex transactional workflows, leading to race conditions, untraceable mutations, and hard-to-test side effects.

With BlocSignal—which bridges Felix Angelov's BLoC architectural rigor with Rody Davis's Preact Signals v7 engine—we have a unified spectrum. State updates propagate synchronously in 0ms, eliminating microtask queue delays while preserving strict architectural boundaries.

Here is the definitive rubric for picking the exact right container for your state.

The 4-Tier State Hierarchy

Rather than forcing every piece of state into the same mold, view your application as a 4-tier hierarchy:

[Raw Signal / computed()]        --> Local widget micro-state & derived calculations
       │
[CubitSignal<State>]             --> Feature domain logic & CRUD with direct method calls
       │
[BlocSignal<Event, State>]       --> Mission-critical pipelines with reified event concurrency
       │
[HydratedMixin / ReplayMixin]    --> Synchronous persistence (Frame 1) & Undo/Redo history

1. Raw Signals: Widget-Local Ephemeral State

Use raw signals (such as signal(), computed(), and the .$ extension syntax) when state is strictly local to a single widget subtree and requires zero backend orchestration.

Ideal Use Cases:

• UI Interactions: Accordion open/close toggles, dropdown menu visibility, modal dialog triggers, and hover states.
• Derived Computations: Calculating an invoice total dynamically from an active item list (computed(() => items.fold(0, (sum, i) => sum + i.price))).
• Direct GPU/Render Bindings: Animation tickers, mouse positions, and custom canvas scroll offsets.

Why It Fits:

Raw signals eliminate class boilerplate entirely. Signal graphs update reactive nodes with sub-millisecond efficiency and are automatically garbage-collected when the hosting widget unmounts.

// Pure view calculation with zero class ceremony
final isExpanded = signal(false);
final totalPrice = computed(() => cart.value.fold(0, (sum, item) => sum + item.price));

Anti-Pattern to Avoid: Never create a full BLoC with separate event classes just to track whether a UI modal is visible.

2. CubitSignal: Feature Domain Logic & CRUD

Use CubitSignal<State> as your default workhorse for standard screen features and business domains.

Ideal Use Cases:

• Standard CRUD Screens: Loading user profiles from a REST/GraphQL API, creating records, updating fields, and deleting rows.
• Form State: Managing form validation errors, submit button spinners, and error alerts.
• Application Settings: Toggling dark mode themes, changing localization languages, and updating account preferences.

Why It Fits:

CubitSignal exposes direct imperative methods (such as cubit.updateName('Alice')), enforcing a clean, predictable unidirectional data flow. You get synchronous in-frame updates, automatic equality de-duplication (if (stateValue == newState) return;), and global observability (BlocSignalObserver) without needing separate event classes.

class ProfileCubit extends CubitSignal<ProfileState> {
  ProfileCubit() : super(initialState: const ProfileState.initial());

  Future<void> updateName(String name) async {
    emit(stateValue.copyWith(name: name, isLoading: true));
    try {
      await userRepository.saveName(name);
      emit(stateValue.copyWith(isLoading: false));
    } catch (error) {
      emit(stateValue.copyWith(isLoading: false, errorMessage: error.toString()));
    }
  }
}

3. BlocSignal: Event Concurrency & Audit Pipelines

Use BlocSignal<Event, State> when your feature requires advanced event coordination, concurrency control, or strict enterprise audit logging.

Ideal Use Cases:

• Event Concurrency Control:
  • restartable(): Debounced live search inputs where new keystrokes cancel prior in-flight network queries.
  • droppable(): Discarding rapid duplicate button taps while a checkout payment transaction is in progress.
  • sequential(): Processing incoming chat messages or write operations in strict FIFO sequence.
• Multi-Step Wizards & Funnels: Checkout pipelines, onboarding flows, and multi-step transaction wizards.
• OpenTelemetry & Compliance Tracing: When every state transition must explicitly record the user action event that caused it (onEvent → onTransition).

sealed class SearchEvent {
  const SearchEvent();
}

final class QueryChanged extends SearchEvent {
  final String query;
  const QueryChanged(this.query);
}

class SearchBloc extends BlocSignal<SearchEvent, SearchState> {
  SearchBloc(this.apiService) : super(initialState: const SearchState.idle()) {
    on<QueryChanged>(
      (event, emit) async {
        if (event.query.isEmpty) {
          emit(const SearchState.idle());
          return;
        }
        emit(const SearchState.loading());
        final results = await apiService.search(event.query);
        emit(SearchState.success(results));
      },
      transformer: restartable(), // Automatically aborts previous query on new input!
    );
  }

  final ApiService apiService;
}

4. Specialized Mixins: Persistence & Undo/Redo

Both CubitSignal and BlocSignal compose with specialized mixins:

• Frame-1 Instant Persistence (bloc_signals_hydrate): Restores cached state synchronously on startup before the first frame renders, preventing loading flashes and layout shifts.
• Undo & Redo History (bloc_signals_replay): Maintains a bounded change stack (cubit.undo(), cubit.redo(), cubit.canUndo) for drawing surfaces, rich text editors, and document builders.

Architectural Comparison Matrix

Syntax Evolution: Dart 3.5 vs. Modern Dart 3.13

Notice how modern Dart 3.13 streamlines event declarations with primary constructors:

Traditional Dart 3.5 Syntax:

sealed class CounterEvent {
  const CounterEvent();
}

final class IncrementRequested extends CounterEvent {
  const IncrementRequested();
}

class CounterBloc extends BlocSignal<CounterEvent, int> {
  CounterBloc() : super(initialState: 0) {
    on<IncrementRequested>((event, emit) => emit(stateValue + 1));
  }
}

Modern Dart 3.13 Syntax:

// Single-line sealed primary constructor hierarchy
sealed class const CounterEvent();
final class const IncrementRequested() extends CounterEvent;

class CounterBloc extends BlocSignal<CounterEvent, int> {
  CounterBloc() : super(initialState: 0) {
    on<IncrementRequested>((event, emit) => emit(stateValue + 1));
  }
}

Try the Interactive Decision Wizard

Want to find the ideal state container for your specific feature?

👉 Try the Interactive State Selector on blocsignal.dev

Select your requirements (concurrency, persistence, undo/redo, scope) and get an instant recommendation with runnable starter code.

AI Coding Assistant Support

If you use Claude Code, Antigravity, or Cursor, BlocSignal includes a pre-packaged AI Agent Skill bundle (bloc-signals) containing these exact architectural rules and validation patterns. Check out the BlocSignal GitHub Repository to explore the 10 modular packages and 25+ runnable examples!

I work across multiple locations. Scotland, England, client sites, my campervan, and sometimes Europe. That means I need a setup that travels without compromise.  A proper second screen, a decent keyboard, and access to my full development environment wherever I land.

This post covers what I’m using and how it fits together.

One thing worth saying upfront: I use this setup on certain projects, not all of them. It is not my daily rig for everything. But when I do need to work remotely and properly, this is what I reach for.

~

The Problem With Most Portable Setups

Most people who work on the road either tolerate a single laptop screen or drag something bulky that makes the whole exercise feel like a punishment.

Neither option works when you’re doing serious development work. Splitting your attention between windows on one screen costs more time than it sounds. Over a long day it adds up.

I wanted two screens, a mechanical keyboard, and my home server available to me regardless of where I was working. The setup I landed on achieves all three without adding meaningful weight to a carry-on bag.

~

The Hardware

First up, the hardware.  I wanted a light but durable bag and a bag I can just grab and go with all my hardware.

Fjällräven Backpack, ~£100

The whole setup lives in a grey Fjällräven backpack. Around £100, and worth it. The build quality is great.  It’s the kind of bag that will outlast most of the tech inside it.

Everything fits without cramming, and it doesn’t draw attention in a coffee shop or airport the way a dedicated tech bag tends to.

It is a small thing, but the bag matters. If carrying the setup is a hassle, you leave it behind. This one never feels like a hassle.

I estimate the total weight of the setup is approx. 4kg.  Without the Starlink mini, the weight is approx. 3kg.

Surface Pro 5 (Reconditioned), ~£150–£300

The foundation of the portable setup. I picked up a reconditioned unit rather than buying new. It handles everything I need at the edge.  Running the RDP client, browser, and supporting tools, while the heavy lifting happens back at the server. Reconditioned made sense given the role it plays.

Tern Setups 16″ Monitor (1200p), ~£179

The second screen. The Tern is a 16-inch IPS panel in an aluminium frame with a magnetic tripod stand. It packs into its sleeve and goes in the Fjällräven alongside everything else without any drama.

The stand gets the monitor to eye level quickly and lets you switch between landscape and portrait without tools. It is stable once positioned, though I noticed a slight tilt if you plug something heavier into the built-in USB-A port. There is a sweet spot, once you find it, it stays put.

The 1200p resolution is more than adequate for .NET development, terminal work, and browser use.

The port selection is better than most portable monitors. USB-A, USB-C, and full-size HDMI are all on board.  My Surface is old so use a USB dongle with HDMI port converter and connect using HDMI.

Logitech M240 Silent Mouse, ~£20

Nothing complicated here. The M240 is a Bluetooth mouse with no dongle required. The silent click is a genuine plus in co-working spaces and coffee shops where you don’t want to be that person. One less thing occupying a port and one less thing to lose.

Keychron K3 Slim Keyboard, ~£105

A low-profile mechanical that pairs well with the compact nature of the setup. The slim profile means it sits naturally next to the Surface without taking over the desk. Typing feel is a clear step up from the Surface keyboard for long sessions, and it is light enough that it barely registers in the bag.

Jackery Explorer 1000 (occasional)

When I am working from the camper rather than a hotel or co-working space, I bring a Jackery Explorer 1000 portable power station. It handles the Surface, the Tern, and anything else that needs charging without needing a mains connection. For camper trips it is the difference between a proper working setup and improvising.

I wrote a full review of the Jackery Explorer 1000 separately if you want more detail on that piece of kit.

Starlink Mini, ~£399 hardware + ~£50/month (Roam plan)

The connectivity fallback. The Starlink Mini is a compact satellite dish, roughly A4-sized and designed to travel. If the local hotel or co-working Wi-Fi is poor, I point the Mini at the sky and connect directly to the Starlink satellite network instead, bypassing ground infrastructure entirely.

It is the one piece of the setup that removes the last remaining variable. Everything else can be sorted on arrival. A bad connection cannot.

~

The Software Layer: Tailscale and RDP

The hardware is only half the picture.

I RDP into my home server over Tailscale. This means I’m always working in the same environment: same tools, same codebase, same terminal history, regardless of which country I’m in or which network I’m on.

Tailscale handles the networking without any configuration overhead. Once set up, it is invisible. I open the RDP client on the Surface, connect to the server, and I’m on my main development machine. The Tern sits alongside as a second display running locally on the Surface for reference material, documentation, or anything that doesn’t need to be on the server.

The practical effect is that the portable workstation has no meaningful ceiling. Everything computationally heavy stays on the server at home. The Surface and Tern are just the interface.

~

How It Travels

The full setup fits in the Fjällräven with room to spare.

• Surface Pro 5
• Tern monitor in its sleeve
• Keychron K3
• Logitech M240 Silent Mouse
• Tern cables (USB-C and HDMI included in the box)
• Starlink Mini
• Chargers

I have used this in the UK, hot desks, airports, Airbnbs in Málaga, and in hotel rooms. It doesn’t feel like a compromise. Setup time from bag to working is under five minutes.

~

What I Would Change

The Tern’s built-in speaker is average. It is there, but you will use your laptop audio or headphones instead. Not really a criticism: most portable monitors have no speaker at all, but worth knowing.

The stand balance point takes a little trial and error when you first use it. Once you know where it is, it is not an issue.

~

Total Cost

A breakdown of the cost can be seen here.

The Starlink Roam plan adds ~£50/month on top, but that is only activated when local connectivity is poor, it is not a permanent overhead.

~

Summary

If you work across locations and want a real development environment rather than a laptop screen and a compromise, this combination covers the requirements without adding bulk.

The Fjällräven carries it all. The Tern provides the second screen. The Keychron provides a keyboard worth typing on. Tailscale and RDP remove the ceiling on what the portable machine can do. The Starlink Mini makes sure the connection is never the weak point.

It is a setup I would put together again without hesitation.

~

~

Sponsorship

Sometimes I get messages asking if I take sponsors.  It’s not something I had considered but after some thought, it makes sense.

I’m opening up a few sponsorship slots on the blog.

A quick bit of context. This site is currently pulling in over 23,000 pageviews a month, read mostly by senior .NET, Azure, AI engineers -and decision makers.

Full details are on the new Sponsor page. If it looks like a fit, drop me a line at admin@jamiemaguire.net and we can talk specifics.

~