<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[George Kamunya]]></title><description><![CDATA[George Kamunya]]></description><link>https://georgekamunya.hashnode.dev</link><image><url>https://cdn.hashnode.com/uploads/logos/6a9d51296df070d0f52d6644/1d238035-c202-45f6-af15-bd6771d956dd.png</url><title>George Kamunya</title><link>https://georgekamunya.hashnode.dev</link></image><generator>RSS for Node</generator><lastBuildDate>Sat, 21 Nov 2026 14:35:53 GMT</lastBuildDate><atom:link href="https://georgekamunya.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[I Built Claude Skills to Handle Both Sides of My 1:1s]]></title><description><![CDATA[Two Claude skills I use daily for 1:1 prep, one for my reports, one for my own manager. Neither trusts an AI notetaker without a human check first.]]></description><link>https://georgekamunya.hashnode.dev/i-built-claude-skills-to-handle-both-sides-of-my-1-1s</link><guid isPermaLink="true">https://georgekamunya.hashnode.dev/i-built-claude-skills-to-handle-both-sides-of-my-1-1s</guid><category><![CDATA[AI]]></category><category><![CDATA[claude]]></category><category><![CDATA[agentic AI]]></category><category><![CDATA[1on1s]]></category><category><![CDATA[engineering-management]]></category><category><![CDATA[Productivity]]></category><category><![CDATA[Career]]></category><category><![CDATA[Software Engineering]]></category><category><![CDATA[Open Source]]></category><dc:creator><![CDATA[George kamunya]]></dc:creator><pubDate>Tue, 15 Sep 2026 20:14:10 GMT</pubDate><enclosure url="https://cdn.hashnode.com/uploads/covers/6a9d51296df070d0f52d6644/61bf3b04-9d0c-45e1-b337-3991c61da750.png" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p>I run 1:1s in both directions every week. Reports come to me, and I go to my own manager. For a long time I prepped for both the same way most people do: a half-remembered sense of what we talked about last time, a scramble through Slack five minutes before the meeting, and a mental note to "follow up on that" that usually didn't survive the rest of the day.</p>
<p>So I built two Claude skills to fix it. One runs the manager side, tracking action items across my reports. The other runs the report side, keeping a running agenda for my own 1:1 with my manager. They're small, they're specific, and I use both of them every day now.</p>
<h3>What the manager-side skill does</h3>
<p><code>manager-1on1-copilot</code> scans my calendar for recurring 1:1-shaped events and confirms the list of people with me, rather than making me type out my own team. From there it asks a handful of setup questions: where reminders should land, where the open-items tracker should live, whether I want a recurring block booked for working through action items, and whether I use a notetaker tool. In my own setup that's Google Calendar, Slack for reminders, Google Docs for the tracker, and Granola as the notetaker, but the skill isn't hard-coded to any of those.</p>
<p>Once that's set up, it runs two recurring jobs. Daily, it drafts a note for any 1:1 that just happened, syncs the open-items tracker from my own corrected notes, reminds me a few days out from each upcoming 1:1 of what's still open, and gives me a same-day briefing before I walk in. Weekly, it nudges me ahead of a recurring review block with a rollup of everything still open across the team. None of this is revolutionary. It's just removing the parts of management that are surprisingly easy to forget.</p>
<h3>What the report-side skill does</h3>
<p><code>report-1on1-prep</code> is the mirror image, built for my own 1:1 with my manager rather than my reports' 1:1s with me. It finds my recurring 1:1 on the calendar (and confirms it with me, rather than assuming), keeps a running agenda of things I want to raise plus open follow-ups on both sides, and reminds me before each meeting what's actually on it. If you're in a matrixed org with two people you report to in some sense, it'll track a second relationship too.</p>
<p>It also lets you choose the shape of the tracker: one simple list, or split into "things to raise," "I owe them," and "they owe me." I use the split version, and it's exposed something I hadn't really noticed before: how often I was the one sitting on a follow-up. Not because I didn't care about it, but because the week moved on and I'd lost track. Turning "I think we talked about this" into something I can actually see has been one of the more useful side effects of the whole setup.</p>
<h3>Why I built both</h3>
<p>The more interesting realization wasn't really about building two separate skills. It was noticing I had the same underlying problem on both sides of the relationship. As a manager, I need to remember what I committed to my reports and what they committed to me. As a report, I need to remember what I committed to my manager and what I need from them. The mechanics are nearly identical; only the direction changes. Once the manager-side skill worked, building the report-side version was mostly a matter of flipping the perspective.</p>
<p>It also changed how I think about 1:1s generally. A good 1:1 isn't really the 30 or 45 minutes of conversation. It's whether the things that come out of that conversation actually get followed through on afterward. That's the part I wanted an agent's help with, not running the meeting, just making sure the meeting didn't evaporate the moment it ended.</p>
<h3>Why neither skill trusts the notetaker</h3>
<p>This is the part of the design I'd actually want another engineering manager to notice. AI notetakers are good, but they're not perfect, they can mishear a name, guess wrong about who owns a follow-up, or misattribute a commitment entirely. Both skills treat notetaker output as a first draft only. It gets delivered to me for review, and the actual tracker only ever gets populated from my own corrected notes, once I've read them and fixed whatever's wrong.</p>
<p>That means there's a short lag between a meeting ending and anything showing up on the tracker. That's intentional, not a bug. An unreviewed misattribution, "my manager promised X," or "this report committed to Y", landing straight into the permanent record of that relationship is worse than a one-time transcription slip I'd normally just catch on a re-read. Given everything I've written about trusting agents with more autonomy, this felt like exactly the wrong place to skip the human step.</p>
<h3>What it actually needs to run</h3>
<p>Both skills need a calendar connector and a way to deliver reminders. My own setup runs on Google Calendar for the former and Slack for the latter, with Google Docs holding the trackers and Granola handling notetaking. None of those are hard requirements, the skills are written against the category of tool (calendar, chat, docs, notetaker), not a specific vendor, so Outlook, email reminders, or Notion would work the same way. For the recurring jobs to run without me manually kicking them off, both skills use Claude's built-in scheduled-task mechanism, that's currently the only place this works out of the box. The docs connector and notetaker integration are both optional either way; without them, the skill falls back to delivering ready-to-paste text instead of writing directly into a doc.</p>
<p>Recurring-event detection off the calendar is a best-effort heuristic, and both skills confirm what they've found with me before building anything on top of it. Neither one attends the meeting or makes a management decision for me. They automate the prep and the tracking. The conversation is still mine.</p>
<h3>Installing it</h3>
<p>Getting either skill running is a five-minute job, not a deployment.</p>
<ol>
<li><p><strong>Get the skill.</strong> Clone the repo:</p>
<pre><code class="language-bash">git clone https://github.com/lemaiyan/pollyskills.git
</code></pre>
<p>Or skip cloning entirely and grab just the packaged skill:</p>
<pre><code class="language-bash">curl -LO https://github.com/lemaiyan/pollyskills/releases/latest/download/manager-1on1-copilot.skill
# swap in report-1on1-prep.skill for the other one
</code></pre>
</li>
<li><p><strong>Install it.</strong> For Claude Code, the fastest way is straight from the repo, no cloning needed:</p>
<pre><code class="language-plaintext">/plugin marketplace add lemaiyan/pollyskills
/plugin install manager-1on1-copilot@pollyskills
</code></pre>
<p>Or drop the folder in manually, into a project's <code>.claude/skills/</code> directory:</p>
<pre><code class="language-bash">cp -r pollyskills/claude/manager-1on1-copilot .claude/skills/
</code></pre>
<p>For Cowork or Claude.ai, upload the packaged <code>.skill</code> file (built with <code>scripts/package-skill.sh</code>) through Settings &gt; Skills &gt; Add, if your org allows skill uploads.</p>
</li>
<li><p><strong>Ask Claude naturally to set it up.</strong> There's no special command, something like:</p>
<blockquote>
<p>"help me stay on top of my 1:1s" "help me prep for my 1:1 with my manager"</p>
</blockquote>
</li>
<li><p><strong>Confirm the recurring 1:1s it found on your calendar.</strong> It won't build anything until you've verified the list is right.</p>
</li>
<li><p><strong>Answer the setup questions it asks you</strong>: where reminders should go, where the tracker should live, and whether you use a notetaker.</p>
</li>
</ol>
<p>There's no config file to hand-edit first, the whole setup happens in that one conversation.</p>
<h3>Where this goes next</h3>
<p>Right now both skills are Claude-specific, they rely on Claude/Cowork's scheduled-task system and skill format, and I don't have a version that runs on cron or a scheduled GitHub Action yet. I'm publishing both on GitHub as-is, Claude-only, with the pieces that would need to change for another platform reasonably contained (the scheduling mechanism, mainly) rather than woven through everything.</p>
<p>If you want to try this with a different assistant entirely, ChatGPT, Gemini, whatever, the actual content of each skill file is just markdown: the setup questions, the logic for how the tracker gets built, the rule about never trusting the notetaker directly. None of that is Claude-specific, and you could paste it into a custom GPT's instructions or a Gemini Gem's system prompt and keep most of the reasoning intact. What won't come with it is the scaffolding around that logic, Claude's connector-based access to your calendar, Slack, and docs, and its built-in scheduled-task mechanism that runs the daily and weekly jobs without you present. You'd be rebuilding those two pieces with whatever equivalent the other platform offers, not dropping in something that already works.</p>
<p>If you do get either skill running on something other than Claude, I'd genuinely like to see it. Open a PR against the repo with what you changed, or just leave a comment here with what worked and what broke, that's exactly the kind of feedback that makes this better for the next person trying the same port.</p>
<p>If you run 1:1s in both directions the way I do, and you're tired of prepping for them from memory, these might save you the same few minutes of scrambling they've saved me. Both skills, along with the install instructions above, are up on GitHub: <a href="https://github.com/lemaiyan/pollyskills">github.com/lemaiyan/pollyskills</a>.</p>
<hr />
<p>If any of this resonated, or you're working through something similar, I'd like to hear about it. Reach me at <a href="mailto:hello@georgekamunya.com">hello@georgekamunya.com</a>, or find more of my writing and work at <a href="https://georgekamunya.com/">georgekamunya.com</a>.</p>
]]></content:encoded></item><item><title><![CDATA[Down, Across, Up: What It Actually Took Me to Learn to Lead]]></title><description><![CDATA[It took three separate mistakes, in three different directions, before I recognized they were the same one. What a manager's offhand comment, a shut-down…]]></description><link>https://georgekamunya.hashnode.dev/down-across-up-what-it-actually-took-me-to-learn-to-lead</link><guid isPermaLink="true">https://georgekamunya.hashnode.dev/down-across-up-what-it-actually-took-me-to-learn-to-lead</guid><dc:creator><![CDATA[George kamunya]]></dc:creator><pubDate>Wed, 09 Sep 2026 13:28:08 GMT</pubDate><enclosure url="https://cdn.hashnode.com/uploads/covers/6a9d51296df070d0f52d6644/88b67c07-906d-4135-9dec-617ec9374c12.png" length="0" type="image/jpeg"/><content:encoded><![CDATA[<blockquote>
<p>A manager once told me I was an enigma.</p>
</blockquote>
<p>It came up in a 1:1 that had otherwise been unremarkable. He told me that if you talked to my reports, or my peers, I was one of the best tech leads around. Talk to him, though, and he couldn't get a straight answer out of me. At the time, I shrugged it off. It didn't feel like a big deal, just one comment in an otherwise ordinary conversation, and I honestly don't remember what I said back. Probably something that proved his point, since not having a good answer was sort of the issue in the first place. But the comment stuck with me in a way ordinary feedback usually doesn't. It took me years to understand why, and longer still to notice that the same mistake kept finding new places to hide.</p>
<p>The short version of how I got there starts with my mother. At 12, she taught me that leadership meant responsibility, not entitlement. Never show up to someone's home empty handed. A few years later, a class teacher made me class monitor, then I became a prefect, and I learned early that leading through influence beat leading through authority. That part I got right, for years. What I hadn't learned yet was what my manager's comment was about to teach me.</p>
<h3>What my manager actually saw</h3>
<p>I started my career as a junior developer, like most of us did back then, and worked my way up through intermediate developer to tech lead. That's where the rubber met the road, and where the comment landed. I was good at the technical work, and good with my team and my peers too. My manager was a different story.</p>
<p>What he meant was specific. He had no real visibility into what was happening with the team. I was making decisions, fielding problems, and mostly keeping them to myself unless something forced my hand. Worse, when the team underperformed, I spent more energy defending them to him than I spent helping them improve. I thought I was protecting my team. I was actually shielding them from accountability, and shielding my manager from information he needed to do his own job. Very noble of me. Also, in hindsight, useless to everyone involved.</p>
<p>Here's the lesson I'd want any engineering manager reading this to sit with: your manager should not have to guess what is happening with your team. Leading your team well and keeping your manager informed aren't competing priorities. Treating them like they were is exactly the mistake I made. It sounds obvious written down like this. It took me years of getting it wrong to actually believe it, not just repeat it.</p>
<p>What I didn't understand at the time was that shielding and guessing were really the same avoidance wearing two different names. I found it easier to manage the story than to have the harder conversation, whether that conversation was with my manager or with my own team. I thought I'd learned a lesson about visibility. I had actually learned that avoiding friction had consequences. I just hadn't yet figured out how often that habit would show up in my leadership.</p>
<h3>What I got wrong with high performers</h3>
<p>I carried that same instinct into my next job. I hadn't fixed the underlying habit, I'd only patched the one place where it had been caught. This time it wasn't my manager I was avoiding friction with. It was my own reports.</p>
<p>The first mistake was trying to make my reports my friends. There is nothing wrong with having a good relationship with your team. I think you should. But there is a difference between having a good relationship with someone and needing that person to like you. I would soften feedback because I knew how it might be received. I'd delay difficult conversations because I didn't want to damage the relationship. Once you blur that line, hard conversations get harder, honest feedback gets harder, and holding someone accountable gets harder. You start making decisions based on the relationship instead of what is best for the person and the team.</p>
<p>The second mistake was how I handled high performers specifically. One senior engineer on my team wanted to write a script to migrate our email templates into JSON blobs, localizations included, real technical debt he'd clearly already thought through and just wanted to go fix. My first instinct wasn't, "Let's figure out if this is a good idea." It was closer to, "Who approved this?" I don't remember exactly what I said, only that it was enough to make him go quiet in a way that told me I'd shut something down rather than redirected it.</p>
<p>That wasn't an isolated moment. I tried to control high performers rather than challenge them, and when they pushed back, I read it as a challenge to my leadership. It wasn't. It was high performers doing what high performers do: push boundaries, ask questions, challenge assumptions. I had that energy right there in front of me, and I spent most of my effort containing it when I should have been pointing it somewhere useful. High performers don't always need more direction. Sometimes they need a bigger problem to solve.</p>
<h3>The migration that taught me to manage stakeholders</h3>
<p>By the time the next problem showed up, it wasn't really a new lesson. I just hadn't recognized it yet. I was tasked with migrating a service from one team to another. The migration itself went well. On paper, we did exactly what we were supposed to do. The problem was that our service had upstream partners depending on it, and I didn't do a good enough job managing those stakeholders or communicating what was happening and what they needed to prepare for. I focused on getting the migration done. I didn't spend enough time making sure everyone around the migration was ready for what came next. The technical work was sound. The project still shipped late.</p>
<p>That distinction mattered more than I expected. You can execute the technical work correctly and still fail at the project. Leadership isn't just about getting your part done. It's about making sure the people around you, above you, and downstream of you can succeed too.</p>
<h3>If you're leading right now, with or without the title</h3>
<p>You don't need a title for any of this to apply. I didn't have one the first time I learned to lead by influence instead of authority, back when I was just a prefect trying to help classmates without abusing whatever pull I had. The same blind spots show up whether you're officially in charge of a team or just the person people already come to. If any of this sounds familiar, someone above you who can't get a straight read on what you're actually doing, a capable person who feels like they're pushing back on you personally, or a project that's technically fine but still lands badly on people outside it, here are the three questions I wish someone had made me ask myself earlier.</p>
<p>Is your manager working from what you actually know about your team, or only from what you've chosen to tell them? Are you challenging your best people, or just trying to keep them contained? And when a project touches someone outside your team, have you told them what to expect, or are you assuming they'll find out when it ships? I didn't ask myself any of those questions the first time around. I found out the answers from a comment, some pushback I mistook for insubordination, and a deadline I missed, three different costs for what turned out to be one habit: choosing the easier conversation over the necessary one, and calling it something else each time. I'd rather you find out from the questions.</p>
<p>Learning to manage up didn't automatically teach me to manage my high performers, and learning that didn't automatically teach me to manage stakeholders. I had to get caught avoiding friction in three different directions before I recognized the pattern. The lesson rarely announces itself as the same lesson twice. Most of us don't become better leaders because someone hands us the title. We become better because we eventually notice the pattern connecting the specific ways we keep getting it wrong.</p>
<p>Leadership was never the title I was given, or the identity that was handed to me as the firstborn. It's the accumulation of every direction I've had to learn to lead in: down, across, up, and sometimes, most importantly, within myself. I'm still working on a few of those directions. I expect I will be for a while yet, and if you're leading anyone right now, whether or not the title says so, I suspect you will be too.</p>
<hr />
<p>If any of this resonated, or you're working through something similar, I'd like to hear about it. Reach me at <a href="mailto:hello@georgekamunya.com">hello@georgekamunya.com</a>, or find more of my writing and work at <a href="https://georgekamunya.com">georgekamunya.com</a>.</p>
]]></content:encoded></item><item><title><![CDATA[From Notepad to Agents: Nearly Twenty Years of My Tools Doing More]]></title><description><![CDATA[A personal look back at 20 years of coding, from Notepad to autonomous AI agents, and what actually changed along the way.]]></description><link>https://georgekamunya.hashnode.dev/from-notepad-to-agents-nearly-twenty-years-of-my-tools-doing-more</link><guid isPermaLink="true">https://georgekamunya.hashnode.dev/from-notepad-to-agents-nearly-twenty-years-of-my-tools-doing-more</guid><category><![CDATA[AI]]></category><category><![CDATA[ai agents]]></category><category><![CDATA[Software Engineering]]></category><category><![CDATA[Productivity]]></category><category><![CDATA[Career]]></category><dc:creator><![CDATA[George kamunya]]></dc:creator><pubDate>Sun, 06 Sep 2026 21:08:57 GMT</pubDate><enclosure url="https://cdn.hashnode.com/uploads/covers/6a9d51296df070d0f52d6644/4b308230-01fa-4304-ae74-2849d2c6dce8.png" length="0" type="image/jpeg"/><content:encoded><![CDATA[<blockquote>
<p>Debugging used to mean scattering print statements and hoping for the best.</p>
</blockquote>
<p>I started coding in Java in 2006, in Notepad. There was no syntax highlighting, no autocomplete, and no inline error checking. If you misspelled a variable, you only found out when you ran <code>javac</code> from the command line. Debugging meant reading your code slowly (often twice) and instrumenting it with printouts; there wasn't much else to rely on. Not out of nostalgia: development was slow, and much of the craft was tolerating the tedium.</p>
<p>Not long after, I picked up .NET: C#, VB.NET, and J#, working mostly in Visual Studio. That was my first real taste of an integrated debugger: stepping through code line by line instead of inferring behavior from logs. J# was Microsoft's attempt at a Java-like language on .NET. I learned most of it from tutorial DVDs because reliable internet was uncommon then.</p>
<p>Then came mobile development. I tried Symbian on Nokia phones using NetBeans but never really got good at it. Eventually I gave up on Symbian and moved to Eclipse to learn Android. That's where mobile development finally started to make sense to me.</p>
<h3>The tools started taking away the boring parts</h3>
<p>Notepad++ was probably my first real upgrade: syntax highlighting, tabs, and a find-and-replace that worked across files. It sounds trivial now, but those conveniences drastically sped up iteration and reduced the friction of switching contexts. Those small wins set the stage for later leaps: full IDEs, better debuggers, and, eventually, intelligent agents.</p>
<p>Then came IntelliJ, and later PyCharm. Autocomplete that actually understood the code you were working with, not just the word you were typing. Refactoring tools that could rename something everywhere it was used, safely, across the whole codebase. At the time, this felt like the tool was finally keeping up with how quickly I could think. Looking back, most of it was just removing friction from things that weren't really the important part of programming anyway.</p>
<p>The same thing happened with languages. You'd learn a new language, and along with the language you'd learn a whole new set of manual habits around how to work with it. Clojure was probably the clearest example of that for me. I spent a few years with it, roughly 2013 to 2016, and it was a completely different way of thinking about code compared to the Java and C# I was used to.</p>
<p>And Stack Overflow was basically part of the development environment. You'd hit an error, search for it, find the answer with the most upvotes, and try it. Except sometimes it wasn't the right answer for your problem. The votes told you that the answer had helped a lot of people, they didn't tell you whether it applied to your particular situation. That gap between the popular answer and the right answer is something we've spent years trying to close.</p>
<h3>Then the tools started writing code</h3>
<p>Generative AI changed this again, and this was different from autocomplete. Instead of finishing the line I was already writing, it could write the whole function. Sometimes an entire feature. And it was right often enough that ignoring it started to feel like a waste of time. There's a <a href="https://arxiv.org/abs/2302.06590">controlled study from Microsoft, GitHub and MIT Sloan</a> that found developers using GitHub Copilot completed a coding task 55.8% faster than developers without it, a pretty significant improvement for a single tool.</p>
<p>But the bigger change wasn't speed. It was where my attention went. I spent less time typing boilerplate and more time asking: <strong>is what it just wrote actually correct?</strong> The work moved up a level.</p>
<p>I started using Copilot with VS Code in plan mode, letting it first work through the task and explain the approach before writing anything. Then I could switch to agent mode and let it make the changes, run the tests, and iterate on the result. It felt like a much bigger shift than autocomplete. The first few times, it honestly felt like I was giving up some of my power as a developer. I wasn't just asking the tool to help me write code, I was giving it enough context to make decisions about the codebase and carry out the work on my behalf. That was useful, but it was also unsettling. The work moved up another level: from writing code, to directing the work, reviewing the decisions, and deciding whether the result was good enough to keep.</p>
<h3>Now the tools don't just write. They act.</h3>
<p>This is where agentic AI feels different to me. An agent isn't just suggesting a line of code for me to accept or reject. I can give it a task and it can go through the repository, understand the code, make changes, run tests, fix things, and potentially open a PR. One I set up was handed nothing more than a one-line spec and came back with a working internal tool; another went looking through a production codebase on its own and reported back a set of N+1 query issues nobody had flagged. That's a very different relationship with the tool, and it took me longer to trust this than it did generative AI. There's a difference between reviewing a line of code suggested by an AI and saying, "Here, take this task and go do it."</p>
<p>I don't think the uneasiness around that is irrational either. You're giving up a certain amount of visibility and control. The system is making decisions while you're not necessarily watching every step. It's reasonable to be uncomfortable with that.</p>
<p>And the interesting thing is that adoption and trust seem to be moving in opposite directions. <a href="https://survey.stackoverflow.co/2025/ai">Stack Overflow's 2025 Developer Survey</a> had AI usage among developers at 84%, up from 76% the year before, a figure also confirmed in their <a href="https://stackoverflow.co/company/press/archive/stack-overflow-2025-developer-survey/">official press release</a>. At the same time, trust in the accuracy of AI output went down. So we're increasingly using tools that we don't completely trust. That feels like an accurate description of where we are right now, and it's pretty close to how I felt when we started introducing agent-based tooling internally this year.</p>
<h3>So what actually changed?</h3>
<p>When I look back over nearly twenty years of development, the tools have changed massively. Notepad gave way to real IDEs, then autocomplete, then generative AI, and now agents. Each step removed more of the mechanical work.</p>
<p>But the thing that hasn't really changed is judgment. Knowing what good code looks like. Knowing what "correct" means. Knowing when something looks right but isn't. Notepad couldn't do that. Neither can the most capable agent. That's still our job, and I think that's probably going to be true for a while.</p>
<p>The part I'm still figuring out now is what this means for engineers earlier in their careers. I learned to code when the tools forced you to do almost everything yourself. They're learning in a world where the tools can do a lot of that work for them. What used to take weeks of trial and error, they can now get in seconds, code that looks plausible and often is. The skill I find myself teaching isn't how to write it anymore; it's how to tell when it's wrong. That's a very different way to learn software engineering, and I think it's probably a post of its own.</p>
<hr />
<p>If any of this resonated, or you're working through something similar, I'd like to hear about it. Reach me at <a href="mailto:hello@georgekamunya.com">hello@georgekamunya.com</a>, or find more of my writing and work at <a href="https://georgekamunya.com">georgekamunya.com</a>.</p>
]]></content:encoded></item></channel></rss>