Treating project managers like kids: 10 relationship-building tips poster parody

Level 1: Just Like Babysitting

Imagine you’re babysitting a toddler. The toddler wants ice cream before dinner, is getting fussy about it, and keeps asking “Why not now?!” every five minutes. How do you handle it? You might start by distracting them with a fun toy or talking about their favorite cartoon (so they forget about the ice cream for a bit). You might let them show you how high they can stack blocks, so they feel proud and happy. You remember to ask them about their day at preschool, and you also tell them about something silly that happened to you today. Maybe you both end up drawing with crayons together for a while. If you accidentally promised something you can’t deliver (“We’ll go to the park later” but it started raining), you say “I’m sorry” and offer a hug. By doing all this, you keep the toddler calm, build trust, and avoid a meltdown.

This meme says that a developer’s relationship with a project manager can be a bit like that babysitting scenario. The project manager is of course an adult, but the joke is that sometimes they can act a little impatient or not understand what’s going on – kind of how a kid doesn’t always understand why they can’t have ice cream immediately. So the developer uses similar tricks: talk about something the project manager likes (maybe sports or movies) to keep things friendly, let the manager feel important by listening to their ideas, share fun stories to make them laugh, and be ready to apologize if something went wrong. It’s funny because in real life you don’t literally think of your boss or manager as a child – but the feeling of keeping an eager, restless person satisfied and cooperative is very much like taking care of a kid. In simple terms, the meme is poking fun at how engineers often have to be patient and gentle with project managers, just like you have to be with little kids, to get things done smoothly. That idea makes people laugh because it’s a silly comparison – and a little truth can be hiding in that silliness. Just like babysitting, working with different personalities in an office takes patience, understanding, and a good sense of humor.

Level 2: Soft Skills 101

In the tech world, a Project Manager (PM) is the person responsible for planning and overseeing work on a project. They set deadlines, assign tasks, track progress, and make sure everyone is on the same page. They often act as the bridge between the engineering team and the business side or clients. Now, developers and project managers sometimes have a notorious communication gap: developers dive into technical details, while PMs focus on timelines, budgets, and big-picture goals. This difference can lead to misunderstandings. Ever heard a junior dev say, “Why doesn’t my manager understand that adding this feature isn’t just a flick of a switch?” Meanwhile, the manager might think, “Why won’t the developer just say it in plain English and give me a yes or no?” These are classic collaboration challenges in corporate tech life.

This meme takes a humorous approach to that situation. Visually, it’s styled like a bright educational poster you’d see in a grade school classroom. We have ten colorful horizontal bars (blue, purple, green, etc.), each with a numbered tip. Originally, as the top text hints, these were “10 Ways to Build Relationships with Kids.” Imagine a teacher’s poster advising how to connect with students: talk about things beyond school, let kids show you their hobbies, remember their pet’s name, laugh with them, that sort of thing. The meme creator has literally crossed out the words “with Kids” in red and written “WITH PROJECT MANAGERS” in bold red letters above it (with a cheeky little “programming” scribbled underneath). So the poster now reads as “10 Ways to Build Relationships with Kids Project Managers.” The effect is immediate and funny: it suggests that dealing with project managers is equivalent to dealing with children, at least in terms of relationship management.

Let’s go through a few of these tips and translate them from the classroom to the office:

1. “Talk to them about non-school related subjects.” In a school, a teacher might chat with a student about their favorite video game or what they did over summer break. In a software team, this means talk to your project manager about things other than work. For example, a developer might start a conversation about a hobby or ask the PM how their weekend was. This builds a relaxed rapport. A junior developer might notice senior teammates casually chatting with the PM about the latest Marvel movie or a football game. That’s not wasted time – it’s relationship-building. It makes working together smoother. When work pressure mounts, that friendly foundation can make tough conversations easier, just like a teacher-student relationship improves if they’ve bonded a bit beyond just homework talk.

2. “Let them teach you about their interests.” A kid might be obsessed with dinosaurs and feel thrilled to tell the teacher all about T-Rex facts. Correspondingly, a project manager often has areas they’re passionate about – maybe a new project management tool or a certification they earned in Agile methodology. If you, as a developer, take a moment to let them explain their fancy Gantt chart or how their scheduling process works, it shows respect. You might actually learn something about how the project is managed at a higher level. More importantly, it makes the PM feel heard and appreciated. For a junior dev, this is a bit counter-intuitive because usually managers teach you the process anyway. But the tip implies actively encouraging them to share. It’s like saying, “Go ahead and walk me through the plan from your side.” This can improve understanding on both ends. Plus, people (of any age) love talking about what interests them. The meme pokes fun at this dynamic because usually we think of managers as the ones guiding us, but here we’re advised to let them feel like the expert educating us – a subtle role reversal!

3. “Remember things about their lives.” In the original context: a teacher remembers that little Johnny has a new baby sister or that Maya won a dance competition – these personal touches mean a lot to kids. In an office, this tip means remember that your PM is a person, too. Maybe they mentioned they love hiking, or that they have a pet parrot, or they just got back from a vacation in Spain. If next time you talk you ask, “Hey, how’s your parrot doing?” or “How was the hike last weekend?”, you’re forging a stronger connection. For a developing engineer early in their career, this might feel nerve-wracking – talking to a manager about non-work stuff! But it humanizes the working relationship. It can turn a potentially dry, transactional interaction into a friendly collaboration. The meme emphasizing this is funny because it implies PMs need the same kind of attentive nurturing as kids. In reality, while PMs are adults, showing that you remember details about them genuinely does improve teamwork. It’s a key part of those famed soft skills in engineering: treating colleagues with empathy and interest.

4. “Share about your own life.” This is the flip side of the above. A teacher might tell students a bit about when they were young or show pictures of their own pet, to make students feel closer to them. Similarly, a developer might share small personal tidbits with a project manager or the team: “I took my bike out for a long trail ride on Sunday, it was awesome,” or “I’m a bit tired today; my baby was up all night.” These aren’t oversharing – just friendly bits that remind everyone we’re human. For a project manager, hearing this can break the ice. It might even help them understand your perspective (e.g., knowing you have a newborn at home might make them a bit more compassionate about your time). In the meme’s lighthearted framing, it’s another way to “manage” your manager by building mutual understanding. It highlights a piece of corporate culture: many successful teams thrive on personal connections, not just pure professional interactions. We often say “communication is key,” and part of communication is knowing who you’re talking with, beyond their job title.

5. “Engage in activities with them” & “Do crazy things.” These two tips (#5 and #8) are about shared experiences. For kids, that’s playing games together or doing a fun project. At work, it might mean participating in non-work activities like team outings, coffee breaks, or even goofy team traditions. If the project manager organizes a team lunch or a silly ice-breaker game during a meeting, joining in (even if you secretly find it cheesy) can strengthen your relationship. “Do crazy things” might sound extreme, but think of it as being open to spontaneity: maybe the PM suggests brainstorming over a walk outside, or they love those trending office challenges (like a plank challenge or a meme contest). When you, the developer, participate or even initiate something playful (like decorating the office for the PM’s birthday or sharing a funny meme on the team chat), it makes the workplace more enjoyable. A junior dev might be shy or all-business initially, but participating in these “crazy” little office moments often helps you bond with the team. The meme uses these tips to humorously imply that sometimes you have to go a bit out of your comfort zone (“crazy things”) to connect with a PM – sort of like doing a silly dance to make a kid laugh. It’s exaggerated for comic effect, but there’s truth in that shared fun breaks down barriers.

6. “Tell hilarious (and even embarrassing) stories.” This encourages openness and humor. In practice, a developer and a PM who can share a laugh will communicate better when things get tough. For example, a developer could recount a funny uni project failure or that time they accidentally spilled coffee on the server (whoops!). If a PM shares a clumsy moment from their past, that vulnerability can make the dev team feel closer to them. The meme is highlighting that laughter is a powerful relationship tool – with kids and with colleagues. A junior developer might notice that senior folks often crack light jokes during stressful times. That’s not unprofessional; it’s a stress-relief tactic that also creates camaraderie. The embarrassing story part? It shows you’re humble and real. In an office, this might be the tech lead joking about how they took down production in their early career. For kids, it might be a teacher humorously recalling being a goofy kid once. See the parallel? The humor in the meme is that we wouldn’t normally equate a professional setting to needing such tactics, but anyone who’s been on an on-call rotation with a panicking manager knows a well-timed funny story (“Let me tell you about the time the entire data center went dark – and how we fixed it”) can diffuse tension.

7. “Share inspirational stories from your life.” In a school context, a teacher might tell students about a challenge they overcame to inspire them. In a tech workplace, this could be a developer sharing with the PM (or team) how they tackled a huge coding bug against the odds, or perhaps how the team pulled together last release and succeeded. It could also mean the PM shares why they care about this project – like a personal anecdote about how the product will help customers. This tip is about motivation and empathy. For a new dev, hearing such stories from a manager can make you understand why they’re so anxious about deadlines (maybe their performance review or a client demo is on the line). And if you share what makes you passionate (or worried) about the work, the PM might better grasp your perspective. The meme plays with this idea by implying you should inspire your PM like you’d inspire a kid who needs encouragement – a bit funny since you’d think adults are self-motivated, but hey, sometimes everyone needs a pep talk.

8. “Use their interests in your lessons and activities.” This one is directly about customizing your communication to the other person’s likes. In engineering, suppose your project manager is a big fan of, say, baseball. You, as the developer, might explain a complex release schedule using a baseball analogy (innings, pitching a save, etc.). If they love data and charts, you might present your progress with a neat graph because you know they’ll dig it. Essentially, speak their language. It’s a crucial skill in bridging that dev–manager gap. A junior engineer might not think to do this at first – you usually explain things from your point of view. But with time, you learn to tailor your explanation to your audience. The meme’s comedic angle is imagining a developer going, “Our code is like your golf game, Bob: we have to take a swing (deploy) and sometimes we end up in the sand trap (bugs), but we’ll get to the green eventually.” It sounds silly – indeed, it’s deliberately silly – but techniques like these are actually taught in advanced communication classes! By exaggerating it, the meme gets a laugh and nods of recognition.

9. “Apologize when you mess up.” This final tip is straightforward and always relevant. If a developer makes a mistake (bug in code, missed deadline), owning it and apologizing to the PM (and team) is crucial. For kids, apologizing when you mess up (like knocking over a cup) is how you build trust and learn responsibility. In an office, a sincere apology can diffuse blame games and show professionalism. Interestingly, as mentioned above, devs sometimes even apologize for things that aren’t entirely their fault just to keep the project moving (“Sorry the deployment is delayed, we hit an unexpected snag” – even if the snag was due to changing requirements). For someone early in their career, it might feel embarrassing to admit fault, but it actually earns respect when done right. The meme includes this because treating a PM like a kid means you might have to be the adult in the room. It’s a witty reminder that sometimes the engineer must be the mature one and say “my bad” first to maintain a good working relationship.

In summary, each item on that list, originally meant for teachers and kids, has a parallel in the developer–PM relationship. The meme humorously teaches soft skills in engineering by framing them as kiddie advice. Why is this so relatable? Because working with diverse personalities in a company often does feel like being in a big sandbox: someone takes someone else’s toy (a project gets re-prioritized), someone throws a tantrum (ahem, high-priority escalation), and someone has to play nice and keep things orderly – often the developer, surprisingly! This poster parody is a lighthearted take on those everyday office moments. The bright colorful horizontal bars and playful font style drive home the contrast between childlike methods and adult workplaces, making the joke obvious even at a glance. And the handwritten annotations (crossing out “kids” to write “project managers”) is a classic meme technique to repurpose content. It tells us the creator saw a direct analogy between managing a classroom of kiddos and managing one enthusiastic (or demanding) project manager.

For a new developer stepping into the corporate world, the underlying message is actually useful: technical skills alone aren’t enough; how you communicate and build relationships with colleagues (yes, even your bosses or PMs) can make a huge difference. It might feel a bit like you’re a teacher or a parent at times, but that’s part of the modern corporate culture in tech – everyone has to collaborate and sometimes that means guiding others gently. And if you ever feel frustrated that your PM “just doesn’t get it,” remember this meme and realize that with a bit of patience, empathy, and perhaps a funny story or two, you can bridge that gap. It’s a lesson many of us learn the hard way, served here in rainbow colors and good humor.

Level 3: The Corporate Kindergarten

At first glance, this meme looks like a cutesy classroom poster — until you see with Kids crossed out and WITH PROJECT MANAGERS scrawled in its place. That cheeky edit immediately tells seasoned devs: "Oh boy, someone’s comparing our office to a kindergarten again." Project managers (PMs) are being equated to kids, and any battle-hardened senior developer who’s survived a few product cycles will smirk at the implication. Why? Because we’ve all been there, gently handling a panicked PM’s expectations as if calming an upset toddler. This humorous juxtaposition taps into the reality of corporate culture where developers often end up doing managing up (basically, handling your boss or PM with as much care as your code). The meme resonates in tech circles as an inside joke about the soft skills and emotional labor engineers invest to keep projects on track and stakeholders pacified.

Let’s break down a few of these “10 Ways” through a senior engineer’s eyes:

• Talk to them about non-school (non-work) subjects – Tip #1 suggests you chat about something besides work. In a dev–PM context, this might mean starting standup not with “Why are we behind schedule?” but with “Hey, how was your weekend? Did your kid win the soccer game?” It’s essentially a distraction technique. Experienced devs know that a PM who sees you as a human being (not just a code machine) tends to be more reasonable. It’s funny because it’s true – sometimes defusing a communication gap is as easy as talking about last night’s game or the local weather, like you would to keep a restless child calm.

• Let them teach you about their interests – That’s tip #2 on the poster. With kids, you’d let them excitedly explain their favorite cartoon. With PMs, this translates to patiently hearing about their new micromanagement fad project management framework or the latest buzzword from the leadership workshop they attended. “Oh, you have a new spreadsheet model for resource allocation? Please, do tell!” You let them feel knowledgeable and valued. The senior dev inside is smirking, but nodding along, because sometimes it’s easier to let the PM feel like the smartest in the room — much like handing a kid a pretend steering wheel so they think they’re driving the car.

• Remember things about their lives & Share about your own life – Tips #3 and #4 are about personal connection. In a technical team, this is gold. A savvy engineer will remember that the PM’s dog was sick or their birthday is next week, and will mention it. Why? It builds trust. And you share a bit about yourself too (maybe that embarrassing story of merging to main without tests once). This humanizes the conversation. To a cynic, it’s like giving the kid an extra cookie before asking them to do something — a little sugarcoating to make the medicine go down. It’s humorous because developer–PM dynamics shouldn’t theoretically require kindergarten tactics, yet here we are. Seasoned devs know a tiny bit of genuine rapport can prevent a collaboration challenge from blowing up. It’s the softer side of engineering that nobody tells you about in computer science class.

• Engage in activities with them & Do crazy things – Tips #5 and #8. With children, “engage in activities” might mean playing tag or finger-painting. In the office, it might mean humoring your PM with those team-building exercises or saying “yes” to that hackathon or off-site retreat they’re excited about. “Sure, I’ll join the Zoom costume party (even though I have 100 lines of code left to debug).” Doing “crazy things” could be as simple as trying the PM’s wacky idea for a sprint to show you’re a team player. Senior developers have learned that occasionally indulging a project manager’s quirky brainstorm (“Let’s use a blockchain for our login system!”) just to explore it can build goodwill — and then you carefully steer them back to reality. It’s all about using their interests and sometimes silly ideas as a bridge to real solutions. The humor here is that wrangling corporate enthusiasm can feel like playing along with a child’s imaginary game — you know where it’s headed, but you let them have a little fun along the way.

• Tell hilarious (and embarrassing) stories & Share inspirational stories – That’s #6 and #7 on the list, and it’s something every senior dev does after a few years: storytelling. Got a war story about that overnight server crash caused by a missed semicolon? Or an inspiring tale about refactoring a legacy monolith into microservices that saved the product? Sharing these with a PM isn’t just vanity — it’s a strategic move. You entertain (hilarious story to lighten the mood, maybe about the time someone deployed to production on Friday and took down the site), and you educate or motivate (inspirational story: “we doubled our throughput after that refactor!”). It’s like reading bedtime stories: one to make the kid laugh, one to make them dream. Here, you’re influencing the PM’s perspective with narratives. It’s comedic to think grown professionals need storytime, but effective PMs actually love a good story. And veteran engineers know that a well-told post-mortem tale can do more to justify a technical decision than a dozen Jira tickets full of technical jargon.

• Use their interests in your lessons and activities – That’s tip #9, which in a classroom might mean designing a math puzzle around a kid’s favorite superhero. In an engineering context, it means framing technical discussions in terms the PM cares about. If your PM is obsessed with Agile velocity or loves football, you use that. “Refactoring this code now is like a good halftime strategy adjustment – it’ll help us score faster later.” See what happened? You translated a code concern into sporty management lingo. It’s a classic senior dev move: speak the PM’s language (even if internally you roll your eyes when saying “synergy” or “quick win”). The meme nails this strategy. We laugh because we recognize the absurdity of doing linguistic gymnastics to explain something simple — but it’s often the only way to get through. It’s the adult equivalent of explaining broccoli is “little trees” so the kid will eat it.

• Apologize when you mess up – Finally, tip #10, a timeless rule for dealing with anyone (kids, PMs, spouses, users, you name it). But here’s the senior-dev kicker: sometimes you apologize even when you didn’t mess up, just to smooth things over. Maybe the deployment failed because requirements changed last minute (cough scope creep courtesy of the PM cough), yet the dev finds themselves saying, “I’m sorry this happened. Let’s fix it together.” It’s conflict resolution 101. You do it with a child to role-model behavior; you do it with a PM to maintain relationship stability. The humor, of course, lies in the role reversal: the developer becomes the mature party owning up, while the PM (the one who might’ve caused the mess by unrealistic demands) is effectively let off the hook — not unlike calming a kid who knocked over the lamp and is about to cry. Management vs Engineering in real life often means the engineer cleans up the mess and apologizes for the disruption, while the manager gets reassured everything’s okay. Darkly funny, isn’t it?

Overall, this meme is a satirical masterclass in developer_PM_dynamics. Each of the ten “tips” is dripping with irony because they apply uncomfortably well to office life. The colorful bars and friendly font scream elementary school, yet the topic is our daily grind with project timelines and status meetings. By presenting soft_skills_in_engineering as literal childcare techniques, the meme highlights the sometimes child-like stakeholder expectations engineers have to manage. Seasoned developers laugh (maybe a tad cynically) because the absurdity hits close to home. It’s a relatable commentary on how much Communication and psychology go into software development beyond just writing code. And behind the laughter is a truth: successful engineering teams aren’t just about brilliant code; they’re about humans working together — even if one of those humans needs the occasional metaphorical juice box and nap time to stay happy.