# The Manager Who Doesn't Use AI Has Already Lost: Hard Skills *Developers code with AI. Designers mock up with AI. QA automates with AI. How about you?* > TL;DR: AI removes the manager's cognitive limit. You should use it to sharpen your decisions, not just to summarize emails. This is the first part of the extended article version of my [ninth talk](https://nerdearla.com/argentina/schedule/el-manager-que-no-usa-ia-ya-perdio/) at [Nerdearla](https://nerdearla.com/), in September 2026. The second part covers the soft skills: managing people. %[https://www.youtube.com/watch?v=Fryfist9ek4] The talk is in Spanish with English subtitles available. ## Get Into the Time Machine Let's travel to the 1990s. Your job was to maintain *Nerdbuster*, a video rental system, in production. ![Nerdbuster](https://cdn.hashnode.com/uploads/covers/5f456a23b9870f18f59a8793/c1540665-81c7-4259-abb4-6305f79cd810.png align="center") Everybody worked together, physically, during office hours, each person in a cubicle with a view of another cubicle. Problems traveled through [the office](https://en.wikipedia.org/wiki/The_Office_\(American_TV_series\)) gossip, the only monitoring system that never went down. The product analyst defined everything months ago with [data flow diagrams](https://en.wikipedia.org/wiki/Data-flow_diagram). Programmers and testers took over the relay at the end, when nothing could change anymore. Managers only supervised. Nobody was sure what that involved, but it sounded important. I'm pretty certain because I was there. It's a caricature for teaching purposes. Don't get mad at me. 😉 # Let's jump to the present. You maintain [*Nerdflix*](https://nerdearla.com/nerdflix/), a streaming platform for nerds, in production. Your team works remotely or in a hybrid model, spread across time zones, languages, and cultures. Somebody is always asleep when you need them. But one thing never changed: > A manager can't be everywhere at the same time. Here's the thesis: **What happens when that cognitive limitation disappears?** ## How to Read This Article Each section compares *Nerdbuster* and *Nerdflix* and uses these markers: - 🧩 A [skill](https://maximilianocontieri.com/ai-coding-tip-004-use-modular-skills) you can build for your AI assistant - 🧭 Human in the loop: the decision that stays with a person - ⚠️ A warning: consent, bias, law, or governance ## Part 1: Managing the Work ### Planning You planned *Nerdbuster* years in advance. You drew two-year [Gantt charts](https://en.wikipedia.org/wiki/Gantt_chart) upfront and measured progress by eye, a polite word for guessing. ![Nerdbuster Gantt chart](https://cdn.hashnode.com/uploads/covers/5f456a23b9870f18f59a8793/ee0b0a18-b698-4bc7-9d75-a0da58e178d5.png align="center") The critical path changed every month, and you redrew it with great ceremony trying to keep up with the current process. You analyzed endlessly without writing a single line of code. When the plan stopped matching reality, you did what managers do: you [micromanaged](https://en.wikipedia.org/wiki/Micromanagement). *Nerdflix* is different: you plan in short, adaptable cycles of a few months. Priorities and dates aren't clear from day one. You start with incomplete information. If they change, you replan fast. You ask the AI to apply the [Theory of Constraints](https://en.wikipedia.org/wiki/Theory_of_constraints) using skills: > `/analyze-constraints`: identifies bottlenecks right away. 🧩 It finds the real bottleneck in your team. It's rarely the person you were about to blame. Ask it which tasks come next, what the constraints are, and what's blocking the team. > `/prioritize`: ranks the work against your goals. 🧩 The AI acts as your copilot. 🧭 **Human in the loop**: The AI suggests adjustments in real time. The team decides how to replan. ### Estimation For *Nerdbuster*, you used the [Delphi method](https://en.wikipedia.org/wiki/Delphi_method) and many other magic methods. You spent months in [analysis paralysis](https://en.wikipedia.org/wiki/Analysis_paralysis), then ran voting rounds with cards, as if poker could predict the future. Behind it all sat the eternal optimism that you could estimate. When you estimated wrong, you lied to yourself: "Never mind. Write it all down. Next time it'll work out." It gave you the illusion of having all the information. But every project is different. Estimating was hard back then. It's even harder today. Don't lie to yourself. 😈 With *Nerdflix*, you don't estimate. You learn as you go. A prioritized backlog changes constantly. > `/prioritize-backlog`: identifies capacity and risk. 🧩 😈 There are no big tasks. There are no epics. That's when the next topic comes in handy: ### Slicing In *Nerdbuster*, someone with experience cut big tasks by hand. They assumed you had all the knowledge at the start, a bold assumption for any project. The pieces came out uneven, with no criteria. The nasty [waterfall](https://en.wikipedia.org/wiki/Waterfall_model). Long milestones sat on a Gantt chart full of fictional dates, closer to sci-fi than to planning. Milestones became deliverables, and deliverables, in theory, released the customer's payments. Real users rarely validated those milestones. Deliveries arrived late, as usual. Tasks lasted months and ended in merge conflicts that pushed the team even further. In *Nerdflix*, you build iteratively and incrementally instead. You knew this in the 1990s. You know it now. You slice each task using different criteria: - Functional: small pieces of functionality you can deliver - Technical: the infrastructure you need You ship to production daily or weekly, and you track the roadmap. 😈 No task lasts more than one day. 😈 No pull request, human or AI, is longer than [two pages](https://maximilianocontieri.com/ai-coding-tip-023-shrink-your-ai-s-pull-request). > `/slicing`: splits each task into small increments you can deliver and verify separately. 🧩 🧭 **Human in the loop**: The team adjusts the slicing and validates the roadmap. ### Prototyping The *Nerdbuster* prototype was a mockup. If you were lucky, a functional one. Or a COBOL shell with a comment: "implement properly after the demos". I worked at a company where that comment was still there 20 years later. True (and sad) story. Today, anyone can build a prototype with [vibe coding](https://maximilianocontieri.com/explain-in-5-levels-of-difficulty-vibe-coding). ![The Homer car](https://cdn.hashnode.com/uploads/covers/5f456a23b9870f18f59a8793/fb2930ff-5842-4c57-a84f-6ca486e95dd2.jpg align="center") That's the good news. You validate it with real users in real time. You find out fast if the idea works and if the customer adopts it. That's also the bad news. Now anyone with a laptop and a free afternoon thinks they can build software. Important rule: **You throw the prototype away in both eras**. 🧭 **Human in the loop**: Nobody merges vibe-coded code without [human review](https://maximilianocontieri.com/ai-coding-tip-006-review-every-line-before-commit). The prototype has no functional validation. Before any of it reaches production, it needs an architecture and design review, a QA review, and your [team standards](https://maximilianocontieri.com/ai-coding-tip-027-force-code-standards). ### Time Tracking In *Nerdbuster*, you logged hours in a spreadsheet "to estimate better next time". You never estimated better next time. This is a real quote I heard from a manager these days: "I want to know what each employee is doing at every moment." In *Nerdflix*, this makes little sense, unless you bill [time and materials](https://en.wikipedia.org/wiki/Time_and_materials). You don't estimate anymore. You manage responsibility and goals in your autonomous teams, not activity. People should raise a flag when they hit a blocker. If you bill time and materials, group the work into task packages and translate them into hours per person. Never measure minute by minute. Keep the tracking anonymous. You want to know what a task cost, not what a person did. Even then, I recommend you avoid it. > `/sum-hours`: turns task packages into hours per person. 🧩 ⚠️ **Consent**: Some companies use intrusive AI to monitor people. Monitoring someone with AI, even to estimate better, is never a unilateral decision. You tell people and ask for consent, or you don't do it. ### Status Reporting In *Nerdbuster*, you collected memos by hand and pinned them to a Taylorist control board. You spent weeks writing endless reports that nobody finished reading. Not even yourself. In *Nerdflix*, you don't need direct reporting. It's welcome if someone asks for it. Risk traffic lights use real indicators. The AI summarizes with evidence: velocity, defects, [service level objectives (SLOs)](https://en.wikipedia.org/wiki/Service-level_objective), and throughput. Since it cites its evidence, you can check every claim. Ask for the project status and you get it instantly: where you are, what you need, what's pending, and the critical path. Everybody knows the project status. Your manager too. 😉 Nobody needs to ask "what are you working on?" anymore. If people are autonomous, you already know. > `/project-status`: builds the status report with risk traffic lights. 🧩 🧭 **Human in the loop**: You review and sign the draft before you send it. ### Documentation and the Bus Factor In *Nerdbuster*, the wiki was outdated, and the folders contradicted each other. Every new tool became the latest fad, and the documentation moved there, leaving the old copy to rot in peace. Each newcomer brought their own system, so several lived side by side. The real knowledge lived in the head of the person who knew how this worked. a.k.a "The Guru". When that person quit, the knowledge left too. You always picked the person who solved things fastest. Congratulations, you built your own [bus factor](https://en.wikipedia.org/wiki/Bus_factor). In *Nerdflix*, you ask the [company brain](https://maximilianocontieri.com/ai-coding-tip-028-build-a-company-brain) directly. You ask. You don't search. It answers with the source cited. You still validate the source. The company brain can be outdated too. The institutional memory accumulates decisions and lessons, session after session. > `/ask-company-brain`: answers with the source cited. 🧩 It's the team version of the [second brain](https://maximilianocontieri.com/ai-coding-tip-020-create-a-second-brain) you build with [Obsidian](https://obsidian.md/) and [Claude](https://claude.com/product/overview). The AI is very good at detecting patterns and risks. It warns you when one person has touched the same code for too long and a knowledge silo is forming. > `/bus-factor`: detects knowledge risks. 🧩 It redistributes knowledge on purpose, with pairing and rotation. ⚠️ **Governance**: You build the company brain with your company's agreement. Never on your own. 🧭 **Human in the loop**: A person validates the source and decides how to redistribute the knowledge. ### Continuous Quality In *Nerdbuster*, quality was reactive. The customer reported a [defect](https://maximilianocontieri.com/stop-calling-them-bugs) informally, without context. It piled up in an endless [Jira](https://www.atlassian.com/software/jira) backlog. Eight hundred defects, and somebody got paid to track them all. You tested manually with spreadsheets. Acceptance needed signatures on paper: "Here's the delivery. Ship it to production." A year later, it reached production, fully signed. Technical debt was a "fix it later" list the business didn't understand or prioritize. In *Nerdflix*, quality is a single cycle: prevent, detect, and prioritize. You translate each piece of technical debt into business risk, in the business's own language. > `/change-risk`: measures the impact of each code change. 🧩 "If I touch this, what can I break?" You anticipate it before QA. > `/defect-triage`: keeps the product at defect zero, like inbox zero, instead of keeping a [list of known defects](https://maximilianocontieri.com/code-smell-179-known-bugs). 🧩 > `/steps-to-repro`: no steps to reproduce, no defect. You [stop patching blind](https://maximilianocontieri.com/ai-coding-tip-037-stop-patching-blind). 🧩 > `/mutation-testing`: checks your tests with [mutation testing](https://en.wikipedia.org/wiki/Mutation_testing). 🧩 > `/test-plan`: drafts the test plan, reusing the tests of a sibling feature, and gives QA options. 🧩 > `/acceptance-tests`: drafts the acceptance tests. 🧩 Once you have the steps to reproduce, the AI proposes a fix. A person validates it and merges it. The defect is gone, and it doesn't come back. 🧭 **Human in the loop**: The QA team and the manager decide what to fix first, whether a risk is acceptable, and which technical debt to prioritize. ### Monitoring and Incidents In *Nerdbuster*, observability meant reading logs by hand. No alerts. The customer was your monitoring system. You found out when they called, or when the phone rang at 3 a.m. You reviewed stack traces reactively. Nobody knew who was on call, so everybody assumed it was somebody else. Most companies had no [site reliability engineering (SRE)](https://en.wikipedia.org/wiki/Site_reliability_engineering) in the 1990s. Then you coordinated the response the traditional way: in a panic. In *Nerdflix*, it's a single cycle. Alerts fire by root cause, with thresholds. The alert triggers a [runbook](https://maximilianocontieri.com/ai-coding-tip-022-give-ai-a-harness-to-work-with). The team meets in a virtual war room. The AI builds the incident timeline. That timeline feeds the post-mortem directly. > `/anomaly-detection`: fires alerts by root cause, for example in [Prometheus](https://prometheus.io/). 🧩 "This system is slow. The data isn't arriving as it should." > `/automatic-remediation`: runs the known fixes. 🧩 Also known as self-healing. Many companies already do this. > `/crisis-procedure`: guides the team through the incident. 🧩 🧭 **Human in the loop**: The team decides what action to take and when to escalate, and supervises everything outside the automated script. The manager is the facilitator. If you're not very technical, your job is to unblock people and set priorities. Don't guess what broke. ### Performance With *Nerdbuster*, you were reactive. The customer complained that something was slow. Only then did you run benchmarks, on demand, preferably after the weekend. With *Nerdflix*, sensors watch your [service level agreements (SLAs)](https://en.wikipedia.org/wiki/Service-level_agreement) and SLOs, and anomaly detection flags deviations. This is a management article. But knowing if your product scales is also your job. The AI is excellent at finding patterns. > `/analyze-profile`: finds where the time goes. 🧩 Use it to find where performance can improve. > `/pareto-in-logs`: finds the 20% of causes behind 80% of the problems. 🧩 🧭 **Human in the loop**: The team decides whether a problem deserves an intervention and which one. The team also weighs the risk before merging the change. ### Releases *Nerdbuster* shipped executables. Sometimes on physical media. You handed the customer a CD or a pen drive and hoped for the best. Versions waited in staging environments, sometimes for almost a year, maturing like a fine wine. *Nerdflix* has [automatic releases](https://maximilianocontieri.com/ai-coding-tip-032-build-a-dark-factory-pipeline). > `/release-monitoring`: watches each release in production. 🧩 Different branches carry different risks. What took a year now takes minutes. > `/critical-customers`: flags the customers a release can hurt the most, using commercial data from the company brain. 🧩 You don't give the alpha to the customer with the riskiest contract. > `/changelog`: writes the changelog. 🧩 ### Other Technical Topics I left out other technical topics (a future article, maybe): - Architecture and stack selection - Security and compliance - Infrastructure costs and AI tokens - [Continuous integration and delivery](https://en.wikipedia.org/wiki/CI/CD) and [DevOps](https://en.wikipedia.org/wiki/DevOps) in detail - Functional analysis (spoiler: [Spec-Driven Development](https://maximilianocontieri.com/ai-coding-tip-008-use-spec-driven-development-with-ai) is *Nerdbuster*) ## Questions From the Audience ### Where Do Business Rules Live? Someone asked about the main source of failures: misreading the requirements. I left functional requirements out on purpose. It's a whole topic. The system must do what the customer asks. It's a contract. Complex business rules must be written down. Don't put them only in the company brain. The company brain is better for the company's culture. And it doesn't compile. Put them in automated tests and acceptance tests, for example with [Cucumber](https://cucumber.io/). The day you break a rule, the company brain says nothing. The test fails and tells you: "You sold A to the customer, and now the system does B." The AI can also check the software against the agreed contract and extract commitments from the minutes. If a customer complains about the same thing again and again, you find out why. ### How Do You Persist the Company Brain? Use [Markdown](https://en.wikipedia.org/wiki/Markdown). It's the same idea as a personal second brain in [Notion](https://www.notion.com/) or [Obsidian](https://obsidian.md/). At first, it's a place to drop things and find links. One day, it starts talking back. On your next project, the company brain says: "Let's not repeat the bad business rule from last time." It closes the loop of the post-mortem. Fool me once, shame on you. Fool me twice, shame on me. Nobody likes to find the same problem twice. Let new problems appear. Never the old ones. ## What Comes Next Everything here was technical. Now comes the part they didn't teach me at computer science university: managing people (now with AI) Meetings, delegating, post-mortems, feedback, salaries and more are in the second part.