<?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" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Paul Cullen Rowe on Medium]]></title>
        <description><![CDATA[Stories by Paul Cullen Rowe on Medium]]></description>
        <link>https://medium.com/@prowe214?source=rss-7e155dae2bc0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*L-fqozBjRlrUQfOzYp8ugQ.png</url>
            <title>Stories by Paul Cullen Rowe on Medium</title>
            <link>https://medium.com/@prowe214?source=rss-7e155dae2bc0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 01:50:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@prowe214/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Coders: Stop Panicking About the Job-Replacing Clankers]]></title>
            <link>https://prowe214.medium.com/coders-stop-panicking-about-the-job-replacing-clankers-5788a7a984c0?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/5788a7a984c0</guid>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Fri, 22 May 2026 18:02:33 GMT</pubDate>
            <atom:updated>2026-05-22T18:02:33.842Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6Wxa-H9SZt3j6FJ-vo0Z0A.jpeg" /><figcaption>Image credit: <a href="https://pixabay.com/users/hansuan_fabregas-2902307/">Hansuan Fabregas via Pixabay</a></figcaption></figure><p>The “AI is taking our software engineering jobs” doomer-loop is mostly noise.</p><p>If you spend your day as a human compiler — translating JIRA tickets into syntax — your seat is probably getting warm.</p><p>For the devs who are strategic thinkers, the job is finally becoming what we were promised it would be… before we got buried in unsexy tedium.</p><h3>Why You’re Better Than AI Alone</h3><p>From a business perspective, there’s a couple obvious reasons why AI isn’t a “workforce killer” for the foreseeable future.</p><ol><li><strong>Real Output Validation:</strong> Almost nobody actually reviews AI output with a fine-toothed comb (okay maybe that’s an exaggeration, but I’m sure you know plenty of coworkers who just fire out pages and pages of work-slop or massive Pull Requests for someone else to review). We’re currently in a world of high-speed, high-confidence hallucination. Sure, you can tokenmax some slop to show you’re a power user of AI, but that’s often a red flag indicating low quality. Those who slow down a bit and sincerely put care and attention into reviewing outputs will be the ones who succeed.</li><li><strong>Enterprises are SLOW to Change:</strong> Large companies move with the agility of a glacier. They can’t swap 5,000 engineers for an AI overnight because they’re simply not willing to let go of that control and accountability. It took enterprises 10+ years to shift to Agile, and the trust required to shift to an AI-native enterprise isn’t coming for a long time.</li><li><strong>Billing is a Dumpster Fire:</strong> CFOs require stability. Right now, AI usage-based billing means a tool can be cheap in one month, and blow an entire budget in the next (<a href="https://www.forbes.com/sites/janakirammsv/2026/05/17/uber-burns-its-2026-ai-budget-in-four-months-on-claude-code/">just look at Uber</a>, who recently blew through their annual AI budget in one quarter). Large businesses won’t bet the farm on a chaotic cost center that has the potential to completely nuke their margins.</li></ol><p><strong>A note on the second point:</strong> We are indeed seeing massive layoffs being publicly attributed to AI efficiency. But take these headlines with a grain of salt, because that attribution is only partially accurate. More often, we’re seeing companies let go of team members who are slow to adopt or actively refusing to use AI in their workflows, then sweeping lower‑performing or overhired employees into that same wave.</p><p>From an objective standpoint, this is understandable. Imagine when computers and spreadsheets first showed up in big companies, and some employees flat‑out refused to use them, clinging to pen‑and‑paper bookkeeping. At some point, the organization has to move forward, even if the way it does that isn’t particularly fair or elegant at the individual level.</p><p>Adapt and move forward with the technology, but also understand its limitations and risks.</p><h3>AI Is A Patterns Tool</h3><p>We need to talk about what these models actually are. Strauss Zelnick, CEO of Take-Two Interactive, put it plainly on a <a href="https://youtu.be/1ZgUcrR0K7I?si=bzLMNHXcmw2fE8-S&amp;t=5750">recent episode of the A16Z Podcast</a>:</p><blockquote>“Remember what AI is, despite the fact that there are people in Silicon Valley who don’t want you to believe this… It’s big data sets, lots of compute, and a large language model mushed together. That’s what they are. So, data sets by their very nature are backward-looking.”</blockquote><p>That “backward-looking” limitation is the hard ceiling of LLM technology. It doesn’t have the capability to push the envelope, create new ideas, or shape culture. That creativity is a deeply human intuition.</p><p>An LLM can generate a clean API controller because ten million people have already built one and posted it online. It cannot tell you how to architect a system for a product that hasn’t been invented yet, or how to pivot your tech stack to exploit a sudden gap in the market. That requires creative, forward-looking, strategic thought.</p><p>Knowing where the semicolons go means competing with a machine that has memorized the entire history of software development. You will lose that race. Moving upstream to the architecture and the “why”, and being able to validate that the “why” was accomplished, is how you lead the future.</p><h3>Shifting to Strategy</h3><p>The job is shifting entirely to orchestration, or being a manager of code rather than its writer.</p><p>My own workflow has completely inverted. I spend 80% of my time in a category of high-level thinking that used to be a luxury:</p><ul><li><strong>Up-front Architecture:</strong> Mapping how systems talk to each other before any code is written.</li><li><strong>Instructional Design:</strong> Building requirements so clear that I can hand them to one AI to generate specific step-by-step instructions for a <em>second</em> coding agent.</li><li><strong>Quality Validation:</strong> Being the final arbiter of “does this actually solve the business problem?”</li></ul><p>I very often use AI to help me craft these plans and fill in the blanks with implementation details that specifically plan around the codebase. But I am the one that controls that creative task and direction, AI just helps me do it faster and more thoroughly.</p><h3>AI Has Eliminated Our Version of “Writers Block”</h3><p>For me, starting something sucks.</p><p>The amount of hours I used to spend dreading a task because I had to set up the environment, configure the boilerplate, and do the tedious bs of basic setup was massive. It’s boring enough to be actual torture. And god forbid I run into a tough config issue when starting a personal project… that alone would be enough to halt the project altogether, and it would become another dead idea.</p><p>AI has deleted that dread. I don’t do the chores anymore. I get to jump straight into the flow state where the actual problem-solving happens. It is fast, and it keeps you fresh. I haven’t felt that “blank page” paralysis in months, and I’m never going back.</p><h3>Thrive, Don’t Just Survive</h3><p>Adaptation looks very similar to every “major shift” we’ve seen in technology.</p><ul><li><strong>Stay Ahead of the Curve: </strong>These tools are changing daily. You don’t need to know every knob and dial, but you do need a working mental model of what’s possible, and be well-versed in a few core tools for your workflow. For a historical example, I personally don’t know the implementation details of every GCP product, but I understand what they’re capable of, and I’m really really good with a few that I use all the time. I have the same knowledge about the neverending list of AI products. That awareness alone keeps compounding your value.</li><li><strong>Learn to Validate:</strong> One of your most valuable skills is now catching bad output before it hits a user. That means spotting hallucinated bugs, being the first “customer” of the system, and iterating until the result actually feels right in human hands.</li><li><strong>Own the Requirements:</strong> If you can’t define the “Why,” the “How” doesn’t matter. Implementation details can vary wildly, what matters is that the solution nails the real user need in the simplest, safest way.</li><li><strong>Automate the Drudge Work:</strong> Let the machines eat the chores. If you’re still hand‑typing boilerplate, you’re volunteering to be slower. Use AI to jump straight to the 80% mark, then spend your energy on the last 20% where judgment, taste, and experience live.</li></ul><p>The software engineers I’ve worked with are some of the smartest people I’ve ever met, and this is a watershed moment for us. The tedious parts of the job that used to occupy 90% of our work — the glue code, the repetitive plumbing, the copy‑pasted patterns — are finally being stripped away.</p><p>For the first time, we’re being paid primarily to think.</p><p><em>Paul is a Principal Software Engineer for </em><a href="https://www.method.com/"><em>Method</em></a><em>, a digital product strategy, design, and engineering firm building the next generation of enterprise technology organizations. Follow him on </em><a href="https://www.linkedin.com/in/paulcullenrowe"><em>LinkedIn</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5788a7a984c0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agentic Coding Harnesses: A Comparison]]></title>
            <link>https://prowe214.medium.com/agentic-coding-harnesses-a-comparison-4db34b87fd5c?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/4db34b87fd5c</guid>
            <category><![CDATA[harness-engineering]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 23:28:35 GMT</pubDate>
            <atom:updated>2026-04-29T23:28:35.949Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*czHO-BKHWDY5OGBMai2Rhw.png" /></figure><p>As LLM models get more powerful and local models have become more approachable, the big discussion lately is how harnesses affect output quality, model lock-in, and choosing the right model for the right task.</p><blockquote>Harnesses have been appearing all over, so why would you use one over another?</blockquote><p>I wasn’t sure, so I did some internet digging, and wanted to share what I’d found.</p><p>Much of what I discovered came from this great <a href="https://medium.com/@itaispector1/the-claude-code-killer-hype-what-pi-and-goose-actually-get-right-and-wrong-fb1a27abb5ce">​⁠Medium post</a> that directly compares Claude Code with slimmer harnesses. That whole post actually complements this article — the one you’re reading — really nicely, so I recommend giving it a read too.</p><p>Here are a few “big-gun” harnesses plus a couple of slimmer ones, with how they differ.</p><h3>Claude Code (Anthropic)</h3><p><a href="https://www.anthropic.com/product/claude-code">Claude Code</a> is the <strong>heavyweight, batteries-included</strong> coding harness around Claude models.</p><p><em>(For context, this is my default today, but </em><strong><em>here’s my complaint</em></strong><em> (as of April 2026) that started all of this research: it feels like the harness is injecting too many system prompts into context, which is causing UX issues, and absolutely nuking token usage. Claude Code used to feel lightweight and smart, but now the UX feels overburdened and often clumsy.)</em></p><h4><strong>Benefits</strong></h4><p>Claude Code shines when you drop it onto a large, unfamiliar codebase and ask it to just work.</p><ul><li>It has strong multi-file reasoning, rich tools (file read/write/edit, bash, web, MCP servers), compaction for long sessions, and orchestration features like sub‑agents and permission modes.</li><li>The system prompt is huge and highly tuned, so you get powerful, hand‑holding behavior out of the box with almost no setup.</li><li>For long‑running work, the wider Claude Agent SDK (which powers Claude Code) shows patterns like initializer + coding agents, feature lists, progress logs, and testing hooks so agents can make incremental progress across many context windows rather than trying to one‑shot everything. <a href="https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents">​⁠Anthropic put out a great research blog about this.</a></li></ul><h4><strong>Drawbacks</strong></h4><ul><li>You pay for that power with <strong>opacity and overhead</strong>.</li><li>The base system prompt alone is 10k+ tokens, and once you add basic tool calls (often 50k+ tokens per subagent lately), MCPs, compaction summaries, and project docs, you can easily burn hundreds of thousands of tokens of context before your actual task even starts.</li><li>You can extend Claude Code, but you don’t really <em>own</em> the harness: the core prompts, behaviors, and tool wiring are closed-source and opinionated.</li><li>It’s also comparatively expensive if you’re on the higher “Max” tiers, which feels like a requirement recently if you’re doing heavy daily usage.</li></ul><h3>Goose (Block / Linux Foundation)</h3><p><a href="https://goose-docs.ai/">Goose</a> is a <strong>model‑agnostic, on‑machine, open‑source agent</strong> that’s exploded in adoption; it’s aimed at replacing paid harness subscriptions with something you control locally.</p><h4><strong>Benefits</strong></h4><p>Goose’s core value is economic and operational: you bring your own API keys, run it locally, and avoid being locked into a specific SaaS harness.</p><ul><li>Data stays on your machine, you can swap models (Anthropic, OpenAI, local via Ollama, etc.), and you sidestep subscription‑style rate limits.</li><li>Its “recipes” are the core driver: YAML‑based, shareable workflows that encode multi‑step processes (e.g. “weekly engineering status from git + issues”) so your whole team can run the same repeatable agentic flow instead of passing prompts around in Slack.</li></ul><h4><strong>Drawbacks</strong></h4><p>You trade ease-of-use for flexibility.</p><ul><li>Goose generally requires more up‑front configuration, especially to get recipes behaving robustly in messy real‑world projects.</li><li>It’s powerful, but closer to “agent platform” than plug‑and‑play co‑pilot.</li><li>Despite the recipe system, the depth of orchestration and integrations still lags Claude Code’s tightly tuned coding experience, particularly around deeply autonomous multi‑file refactors and CI/PR workflows.</li><li>Governance under a foundation promises longevity, but can slow product‑level iteration compared to a tightly focused vendor.</li></ul><h3>Pi Coding Agent (Mario Zechner)</h3><p><a href="https://pi.dev/">Pi</a> is the <strong>minimalist, open‑source coding harness</strong> that’s become the canonical “slim but powerful” counterpoint to Claude Code. It’s a TUI that wraps <strong>any</strong> LLM with a tiny, transparent system prompt and just a few core tools. From there, you bolt on what you need, fully tuning it to your personal way of working.</p><h4><strong>Benefits</strong></h4><p>Pi’s thesis is that you, not the harness, should control the context window.</p><ul><li>Its system prompt plus tools are under ~1k tokens, versus the ~10k+ you see in opinionated harnesses, so almost all of the context budget is your repo, your plans, and your docs.</li><li>Every prompt and tool call is visible and inspectable; you define behavior via markdown files (AGENTS.md / CLAUDE.md, prompts, skills) and TypeScript extensions.</li><li>It supports hundreds of models across many providers and gives you deep control over the terminal UI, hooks, tools, and event loop.</li><li>Conceptually, it’s more like a composable library than a framework: you’re doing harness engineering, not just using someone else’s defaults.</li></ul><p><a href="https://agenticengineer.com/the-only-claude-code-competitor">Here’s a hot take about Pi</a> from AgenticEngineer, which begins the post by making the bold claim that “Claude Code is the starter pack, but Pi is the endgame.”</p><h4><strong>Drawbacks</strong></h4><p>The flip side of minimalism is that <strong>you must provide the structure</strong>.</p><ul><li>To get great results, you’re expected to curate plan files, todo files, and explicit context rather than lean on a huge system prompt to infer everything.</li><li>Out‑of‑the‑box, it feels raw compared to Claude Code; the learning curve includes both the Pi abstractions and your own extension scaffolding.</li><li>You gain power only if you’re willing to invest in customizing the harness and maintaining your own conventions over time.</li></ul><h3>“Slimmer” harness examples &amp; patterns</h3><p>Beyond Pi, there are other lightweight harnesses people gravitate to when they want minimal surface area and high control rather than giant frameworks.</p><ul><li>On the open‑source side, you see smaller agentic shells and harnesses in Python, Go, or Rust where the entire loop is “model + tools + a few hooks,” sometimes explicitly inspired by Pi’s design.</li><li>In <a href="https://www.reddit.com/r/LocalLLaMA/comments/1swn5z5/are_there_any_agentic_coding_harnesses_that_arent/">community discussions</a>, a common recommendation is to take a minimal harness you like (Pi, a basic Python or Rust agent, etc.) and clone/adapt it to your stack, because the core loop is straightforward: a REPL around the model with callbacks, a bit of state, and tool wiring. This keeps dependency surface and prompting fully under your control, at the cost of building more yourself.</li></ul><p>These slimmer harnesses typically:</p><ul><li>Use small, explicit prompts and a handful of tools.</li><li>Avoid opaque compaction layers and hidden tokens.</li><li>Emphasize sandboxing and permission boundaries over complex, baked‑in behavior.</li><li>Expect you to bring your own project structure, docs, and workflows.</li></ul><p>They won’t match Claude Code’s “drop me on a monorepo and go” capability, but they appeal if you care about reproducibility, debuggability, and attack surface more than fancy UX.</p><h3>Notable but not included</h3><p>There are some other popular options that I wanted to explore, but don’t really fit this category. I’ll name them here anyway:</p><p><strong>OpenClaw</strong> — a general agent harness with tools, memory, and multi‑provider support, originally focused heavily on coding and repo work, and packed with power. But its taken on a massive life since then, and I wanted to focus on slim harnesses.</p><p><strong>Hermes</strong> — a self-hosted, self-improving “generalist” agent that happens to be very good at coding, but is really aimed at being your long‑running automation brain. It sits closer to “Claude Code + personal butler + cron daemon” than to a slim IDE copilot.</p><p><strong>Cursor</strong>, <strong>Cline</strong>, <strong>VSCode</strong>, etc — these are full IDE-first tools. They have harness functionality but… a full IDE just feels like a different category.</p><h3>How to choose between them</h3><p>If you want <strong>maximum autonomous power on big codebases with minimal setup</strong>, Claude Code is still the benchmark; you’re renting a very sophisticated harness plus frontier models. Honestly this is still my default today, and I’ll often flavor it with <a href="https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04">Gas Town</a> if I have a boatload of pre-planned work ready to go.</p><p>If your pain is <strong>cost, lock‑in, or rate limits</strong> and you’re comfortable configuring a platform, Goose gives you a more economical, self‑hostable, recipe‑driven harness on top of the same models. This is the pain point that is starting to arise for me, which is why I researched this in the first place.</p><p>If you care most about <strong>owning the harness and its behavior</strong>, with full visibility into every token and tool call, Pi and similar minimalist harnesses are the better fit, at the cost of more up‑front harness engineering and ongoing maintenance. I’m exploring this as a foundation for client projects that call for building a custom internal agent ecosystem.</p><p>Pick based on what currently hurts more for you: lack of control, lack of power, or cost/constraints.</p><p>Paul is a Principal Software Engineer for <a href="https://www.method.com/">Method</a>, a digital product strategy, design, and engineering firm building the next generation of enterprise technology organizations. Follow him on <a href="https://www.linkedin.com/in/paulcullenrowe">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4db34b87fd5c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI for Software Engineers: A Practical Getting Started Guide]]></title>
            <link>https://prowe214.medium.com/learn-ai-for-software-engineers-57630144362a?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/57630144362a</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Fri, 18 Jul 2025 17:11:08 GMT</pubDate>
            <atom:updated>2025-07-18T17:11:08.585Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FRk03oP5PWWSCgdhqbe1Mg.png" /></figure><p><em>“So everyone’s building AI stuff except me. Cool. Cool cool cool.”</em></p><h3>Welcome to the Party (Better Late Than Never)</h3><p>You’ve been building rock-solid applications for years, maybe decades. You’ve weathered the JavaScript framework wars, survived the microservices revolution, and somehow made it through the Docker container craze with your sanity intact. But now everyone’s talking about AI, and suddenly you’re feeling like you missed the boat on something important.</p><p>I felt the same way. This stuff moves FAST.</p><p>But don’t panic. You’re not behind — you’re just fashionably late to a party that’s still just getting started.</p><p>Let’s run through what’s happening these days.</p><h3>The Four Main Concepts of AI (And Which Ones You Should Care About)</h3><p><strong>1. Using AI Tools (</strong>✨<strong>Start Here</strong>✨<strong>)</strong></p><ul><li><strong>What it is</strong>: Leveraging existing AI services and models to enhance your applications</li><li><strong>Think of it as</strong>: Using a database or payment processor — you don’t build it, you integrate it</li><li><strong>Examples</strong>: Adding chatbots to your app, image recognition for user uploads, code completion in your IDE</li><li><strong>Investment level</strong>: Low to medium effort, high immediate value</li></ul><p><strong>2. Building AI-Powered Applications (Your Sweet Spot)</strong></p><ul><li><strong>What it is</strong>: Creating applications that consume AI APIs and services as core functionality</li><li><strong>Think of it as</strong>: Building a web app that happens to be really smart</li><li><strong>Examples</strong>: Customer service dashboards with AI insights, content creation tools, smart data analysis platforms</li><li><strong>Investment level</strong>: Medium effort, leverages your existing skills</li></ul><p><strong>3. Building AI Agents (Automation and Workflows)</strong></p><ul><li><strong>What it is</strong>: Creating intelligent systems that can make decisions, take actions, and complete multi-step workflows autonomously</li><li><strong>Think of it as</strong>: Building a smart assistant that can actually do things, not just answer questions</li><li><strong>Examples</strong>: Automated customer support systems, intelligent content pipelines, smart business process automation</li><li><strong>Investment level</strong>: Medium to high effort, combines your existing skills with new workflow thinking</li></ul><p><strong>4. Building AI Models/LLMs (The Deep End)</strong></p><ul><li><strong>What it is</strong>: Creating, training, and fine-tuning machine learning models from scratch</li><li><strong>Think of it as</strong>: Building your own database engine instead of using PostgreSQL</li><li><strong>Examples</strong>: Custom language models, computer vision systems, recommendation engines</li><li><strong>Investment level</strong>: High effort, requires specialized knowledge and significant resources</li></ul><blockquote><strong>FYI</strong>: This post focuses on <strong>#2</strong> and <strong>#3</strong> because that’s where your software engineering skills shine brightest.</blockquote><h3>The Tool Ecosystem: Your New Best Friends</h3><p>(Keep in mind that the AI tools ecosystem changes <em>sofrickinfast</em>, and these recommendations are current as of July 2025)</p><h4>APIs and Services (The Easy Button)</h4><p><strong>OpenAI API</strong></p><ul><li><strong>What it does</strong>: Text generation, code completion, image creation, embeddings</li><li><strong>Real-world use</strong>: GitHub Copilot, ChatGPT integrations, content creation tools</li><li><strong>Why you’ll love it</strong>: RESTful API, excellent documentation, familiar request/response patterns</li></ul><p><strong>Anthropic Claude API</strong></p><ul><li><strong>What it does</strong>: Conversational AI, text analysis, code review</li><li><strong>Real-world use</strong>: AI assistants, document analysis, code explanation tools</li><li><strong>Why you’ll love it</strong>: Strong reasoning capabilities, good at following complex instructions</li></ul><p><strong>Google AI Platform / Gemini / Vertex AI</strong></p><ul><li><strong>What it does</strong>: Everything from pre-trained models to custom ML pipelines</li><li><strong>Real-world use</strong>: Gmail’s Smart Compose, Google Photos object recognition</li><li><strong>Why you’ll love it</strong>: Scales with Google’s infrastructure, integrates with existing Google Cloud services</li></ul><p><strong>AWS Bedrock</strong></p><ul><li><strong>What it does</strong>: Access to multiple AI models through a single API</li><li><strong>Real-world use</strong>: Enterprise chatbots, content moderation, data analysis</li><li><strong>Why you’ll love it</strong>: Multiple models, one interface, AWS reliability</li></ul><h4>Development Frameworks (The Scaffolding)</h4><p><strong>LangChain</strong></p><ul><li><strong>Purpose</strong>: Orchestrating AI workflows and chaining multiple AI operations</li><li><strong>When to use</strong>: Building complex AI applications that need multiple steps</li><li><strong>Think of it as</strong>: Express.js for AI applications</li></ul><p><strong>Hugging Face Transformers</strong></p><ul><li><strong>Purpose</strong>: Easy access to pre-trained models</li><li><strong>When to use</strong>: When you need specific models or want to run inference locally</li><li><strong>Think of it as</strong>: npm for AI models</li></ul><p><strong>Vector Databases (Pinecone, Weaviate, Chroma)</strong></p><ul><li><strong>Purpose</strong>: Storing and searching through AI-generated embeddings</li><li><strong>When to use</strong>: Building search, recommendation, or RAG (Retrieval Augmented Generation) systems</li><li><strong>Think of it as</strong>: Elasticsearch for semantic search</li></ul><h4>Agentic Workflow Automation (The Team Of Robots)</h4><p><strong>n8n</strong></p><ul><li><strong>Purpose</strong>: Visual workflow automation with AI integrations</li><li><strong>When to use</strong>: Building complex business processes that combine AI with traditional tools</li><li><strong>Think of it as</strong>: Zapier or IFTTT meets AI, but with actual programming flexibility</li><li><strong>Real-world use</strong>: Automated content pipelines, customer onboarding flows, data processing chains</li></ul><p><strong>LangFlow</strong></p><ul><li><strong>Purpose</strong>: Visual interface for building LangChain workflows</li><li><strong>When to use</strong>: Creating complex AI agent workflows without writing code</li><li><strong>Think of it as</strong>: Visual programming for AI agents</li><li><strong>Real-world use</strong>: Multi-step reasoning systems, automated research workflows, complex decision trees</li></ul><p><strong>Microsoft Power Automate + AI Builder</strong></p><ul><li><strong>Purpose</strong>: Enterprise workflow automation with AI capabilities</li><li><strong>When to use</strong>: Integrating AI into existing Microsoft ecosystems</li><li><strong>Think of it as</strong>: The enterprise-friendly version of workflow automation</li><li><strong>Real-world use</strong>: Document processing pipelines, automated approvals, business intelligence workflows</li></ul><h3>Real-World Applications: Where AI Actually Lives</h3><h4>Customer Service &amp; Support</h4><ul><li><strong>The problem</strong>: Scaling human support is expensive and slow</li><li><strong>The AI solution</strong>: Chatbots that can handle 80% of common questions, escalate complex issues</li><li><strong>Your opportunity</strong>: Build intelligent support dashboards, automated ticket routing, sentiment analysis</li></ul><h4>Content Creation &amp; Management</h4><ul><li><strong>The problem</strong>: Creating and managing content at scale</li><li><strong>The AI solution</strong>: AI-assisted writing, image generation, content optimization</li><li><strong>Your opportunity</strong>: Content management systems with AI suggestions, automated social media tools</li></ul><h4>Data Analysis &amp; Insights</h4><ul><li><strong>The problem</strong>: Humans can’t process massive datasets quickly</li><li><strong>The AI solution</strong>: Natural language queries, automated report generation, anomaly detection</li><li><strong>Your opportunity</strong>: Business intelligence tools that speak human, automated data pipelines</li></ul><h4>Code &amp; Development</h4><ul><li><strong>The problem</strong>: Repetitive coding tasks, documentation, code review</li><li><strong>The AI solution</strong>: Code completion, automated testing, documentation generation</li><li><strong>Your opportunity</strong>: Developer tools, automated code review systems, smart IDEs</li></ul><h4>Workflow Automation &amp; Business Process</h4><ul><li><strong>The problem</strong>: Manual, repetitive business processes that require human decision-making</li><li><strong>The AI solution</strong>: Intelligent agents that can handle multi-step workflows, make decisions, and integrate with existing tools</li><li><strong>Your opportunity</strong>: Process automation platforms, intelligent document processing, automated customer journey orchestration</li></ul><h3>Your Path Forward: Building AI-Consuming Applications</h3><h4>Phase 1: Get Your Feet Wet (Week 1–2)</h4><p><strong>Start with a simple project:</strong></p><ol><li><strong>Pick a familiar domain</strong>: Use something you already understand (e-commerce, blogging, project management)</li><li><strong>Add one AI feature</strong>: Maybe a product description generator or smart search</li><li><strong>Use a simple API</strong>: OpenAI’s GPT-4 API is beginner-friendly</li><li><strong>Keep it simple</strong>: Focus on the integration, not the AI complexity</li></ol><p><strong>Suggested first project</strong>: A blog post title generator</p><ul><li>Input: Blog post content</li><li>AI processing: Summarize and suggest catchy titles</li><li>Output: List of title options</li><li>Skills practiced: API integration, prompt engineering, error handling</li></ul><h4>Phase 2: Get Comfortable (Week 3–6)</h4><p><strong>Build something more complex:</strong></p><ol><li><strong>Add user management</strong>: Let users save their AI interactions</li><li><strong>Implement rate limiting</strong>: Handle API costs and limits</li><li><strong>Add error handling</strong>: AI APIs can be flaky</li><li><strong>Optimize prompts</strong>: Learn how to get better results from AI models</li></ol><p><strong>Suggested project</strong>: A code review assistant</p><ul><li>Input: Code diffs or pull requests</li><li>AI processing: Analyze code for issues, suggest improvements</li><li>Output: Structured feedback with severity levels</li><li>Skills practiced: Complex prompting, structured data handling, webhook integration</li></ul><h4>Phase 3: Get Serious (Week 7–12)</h4><p><strong>Build a production-ready application:</strong></p><ol><li><strong>Implement caching</strong>: AI API calls are expensive</li><li><strong>Add monitoring</strong>: Track usage, costs, and performance</li><li><strong>Build a feedback loop</strong>: Let users rate AI responses</li><li><strong>Consider fine-tuning</strong>: Customize models for your specific use case</li></ol><p><strong>Suggested project</strong>: A customer support assistant</p><ul><li>Input: Customer messages, conversation history, knowledge base</li><li>AI processing: Context-aware responses, sentiment analysis, escalation triggers</li><li>Output: Suggested responses, action items, customer insights</li><li>Skills practiced: RAG implementation, conversation management, business logic integration</li></ul><h4>Phase 4: Enter the Agent Era (Month 4–6)</h4><p><strong>Build intelligent workflow automation:</strong></p><ol><li><strong>Explore visual workflow tools</strong>: Try n8n or LangFlow for complex multi-step processes</li><li><strong>Create AI agents</strong>: Build systems that can make decisions and take actions</li><li><strong>Integrate multiple services</strong>: Connect AI with your existing tools and databases</li><li><strong>Handle complex decision trees</strong>: Build workflows that can branch based on AI analysis</li></ol><p><strong>Suggested project</strong>: An intelligent content publishing workflow</p><ul><li>Input: Draft content, brand guidelines, target audience</li><li>AI processing: Content optimization, SEO analysis, scheduling decisions, social media adaptation</li><li>Output: Optimized content published across multiple channels with performance tracking</li><li>Skills practiced: Multi-step workflows, decision logic, API orchestration, monitoring complex systems</li></ul><h3>Key Concepts to Master</h3><h4>Prompt Engineering</h4><ul><li><strong>What it is</strong>: Writing effective instructions for AI models</li><li><strong>Why it matters</strong>: This is the most important skill, and can be the difference between generating gibberish or gold</li><li><strong>Key skills</strong>: Clear instructions, role definition, context setting, output formatting</li></ul><h4>RAG (Retrieval Augmented Generation)</h4><ul><li><strong>What it is</strong>: Combining AI models with your own data or documents by retrieving relevant information before generating responses</li><li><strong>Why it matters</strong>: Makes AI responses more accurate and grounded in your specific context</li><li><strong>Key skills</strong>: Document chunking, embedding generation, similarity search, context injection</li></ul><h4>Rate Limiting and Cost Management</h4><ul><li><strong>What it is</strong>: Controlling API usage to manage costs and avoid limits</li><li><strong>Why it matters</strong>: AI APIs can get expensive quickly</li><li><strong>Key skills</strong>: Caching strategies, request batching, cost monitoring</li></ul><h4>Error Handling and Fallbacks</h4><ul><li><strong>What it is</strong>: Gracefully handling AI failures and edge cases</li><li><strong>Why it matters</strong>: AI models aren’t 100% reliable</li><li><strong>Key skills</strong>: Retry logic, fallback responses, user experience design</li></ul><h4>Agentic Workflows and Decision Trees</h4><ul><li><strong>What it is</strong>: Building AI systems that can make decisions and take actions across multiple steps</li><li><strong>Why it matters</strong>: Enables complex automation that goes beyond simple input/output</li><li><strong>Key skills</strong>: Workflow orchestration, conditional logic, multi-step reasoning, tool integration</li></ul><h4>Embeddings and Vector Search</h4><ul><li><strong>What it is</strong>: Converting text into numerical representations for similarity search</li><li><strong>Why it matters</strong>: Enables semantic search and recommendations</li><li><strong>Key skills</strong>: Understanding similarity, implementing search, managing vector databases</li></ul><h3>Common Pitfalls (And How to Avoid Them)</h3><p><strong>The “AI Will Do Everything” Trap</strong></p><ul><li>AI is a tool, not a magic, all-powerful, sentient being</li><li>Start with narrow, specific use cases</li><li>Build traditional software that happens to use AI</li></ul><p><strong>The “Perfect Prompt” Obsession</strong></p><ul><li>Prompts will never be perfect</li><li>Focus on “good enough” and iterate</li><li>ALWAYS build systems to handle imperfect responses</li></ul><p><strong>The “Free API” Illusion</strong></p><ul><li>AI APIs cost money, sometimes a lot</li><li>Plan for scaling costs early</li><li>Implement usage tracking from day one</li></ul><p><strong>The “AI Agent Will Replace Everything” Trap</strong></p><ul><li>Agents are powerful but not magic</li><li>Start with simple, single-purpose workflows</li><li>Build reliability before complexity (small and simple tasks is the key to reliability)</li><li>Remember that agents can (and will) fail in spectacular ways</li></ul><h3>Your Action Plan To Learn</h3><h4>This Week</h4><ol><li>Sign up for OpenAI API (or your preferred service)</li><li>Build a simple “Hello World” AI integration</li><li>Read the API documentation thoroughly</li><li>Join AI-focused developer communities</li></ol><h4>This Month</h4><ol><li>Complete your first AI-powered feature</li><li>Deploy it to production (even if it’s just a side project where you’re the only user)</li><li>Start tracking costs and usage patterns</li><li>Experiment with different AI models and services</li></ol><h4>Next Three Months</h4><ol><li>Build a complete AI-powered application</li><li>Learn about prompt engineering and optimization</li><li>Implement proper error handling and fallbacks</li><li>Start thinking about your next AI project</li></ol><h4>Next Six Months</h4><ol><li>Experiment with agentic workflows and automation</li><li>Build a system that integrates multiple AI services</li><li>Explore visual workflow tools like n8n or LangFlow</li><li>Create intelligent agents that can make decisions and take actions</li></ol><h3>My Final Thoughts On AI… At Least For Now</h3><p>AI isn’t replacing software engineers — it’s making us more powerful. By learning to build applications that consume AI services, you’re not just keeping up with the times; you’re positioning yourself at the forefront of the next wave of software development.</p><p>The best part? You already have 90% of the skills you need. API integration, error handling, user experience design, scalability concerns — these are all problems you’ve solved before. AI just gives you a new, incredibly powerful tool to solve them with.</p><p>So stop overthinking it. Pick a simple project, integrate an AI API, and start building. The future of software development is here, and it’s surprisingly familiar.</p><p>Paul is a Principal Software Engineer for <a href="https://www.method.com/">Method</a>, a digital product strategy, design, and engineering group building beautiful user-facing experiences. Follow him on <a href="https://www.linkedin.com/in/paulcullenrowe">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=57630144362a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engineering Leadership 101: Steering Clear of High-Risk Practices]]></title>
            <link>https://prowe214.medium.com/engineering-leadership-101-steering-clear-of-high-risk-practices-f3254bfee088?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3254bfee088</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[engineering-management]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Mon, 28 Oct 2024 22:39:39 GMT</pubDate>
            <atom:updated>2024-10-30T00:31:32.855Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*vAzelDqsN4X-IInEytvRiQ.jpeg" /></figure><p>In software engineering, we’ve all felt the pressure of a looming deadline, urgent requirements, and demanding customers, making it tempting to augment our processes in order to accelerate our work.</p><blockquote>Not only is this behavior risky in itself, but it also introduces a dangerous precedent to the team: <strong>“Since we took a shortcut today, why shouldn’t we take another shortcut tomorrow?”</strong></blockquote><p>Sometimes, we don’t even know we’re missing something in our process, and accidentally have introduced risk into our development lifecycle.</p><p>After seeing these mistakes at many companies and clients over the years, I consolidated a list of 20 process shortcuts that can severely increase risk of a production release if left unconsidered.</p><h3>1. Skipping Code Reviews</h3><p>Rushing through or skipping code reviews introduces the risk of missing critical bugs or architectural issues. Even experienced developers benefit from a second pair of eyes on their code.</p><h3>2. Ignoring Test Coverage</h3><p>Failing to maintain adequate test coverage, especially for critical parts of the codebase, can lead to bugs going undetected. Automated tests — unit tests, integration tests, and end-to-end tests — provide an essential safety net before pushing changes to production.</p><h3>3. Not Setting Up Rollback Plans</h3><p>Deploying without a clear rollback strategy can turn small mistakes into major incidents. Always ensure you have a tested and reliable rollback plan for releases, in case something goes wrong.</p><h3>4. Ignoring Technical Debt</h3><p>Accumulating technical debt without addressing it increases maintenance costs and slows down future development. Prioritizing new features at the expense of refactoring or fixing old code can lead to long-term instability.</p><h3>5. Deploying Large Changes at Once</h3><p>Deploying significant changes in a single release increases the risk of failures. Break down changes into smaller, manageable units and deploy incrementally to make debugging easier and reduce potential impact.</p><h3>6. Releasing on Fridays or Weekends</h3><p>Releasing code right before the weekend is risky since fewer engineers will be available to handle issues that arise in production. It’s best to release earlier in the week when support is readily available to monitor and address problems.</p><h3>7. Lack of Documentation</h3><p>Failing to maintain up-to-date documentation for new features, architecture changes, and dependencies can leave the team in a bind when something breaks or when new team members join. Comprehensive documentation ensures smoother onboarding and quicker resolution of issues.</p><h3>8. Not Involving QA Early</h3><p>If Quality Assurance (QA) is only involved at the end of the development cycle, bugs may be caught too late, delaying releases. Engaging QA throughout development helps identify issues earlier.</p><h3>9. Ignoring Performance and Scalability Testing</h3><p>Releasing features without testing their performance at scale can lead to production failures under heavy load. Regularly conduct stress and load testing to ensure the system can handle real-world usage.</p><h3>10. Over-Reliance on Hotfixes</h3><p>Fixing production issues with quick hotfixes without addressing the root cause introduces long-term instability. Focus on solving problems systematically rather than relying on temporary solutions.</p><h3>11. Hiding Bad News From Stakeholders</h3><p>Things are never going to go completely smoothly, but hiding these issues causes bigger problems. Failing to communicate problems or risks to stakeholders, including product owners, executive sponsors, and other teams consuming your product, ultimately sows distrust, and prevents the team from discovering and improving points of friction.</p><h3>12. Deploying Without Staging Environment Testing</h3><p>Skipping the testing of new code in a staging environment that closely mirrors production is a common risk. Without this step, potential issues might only surface in production, affecting real users and potentially causing downtime.</p><h3>13. Underestimating Production Monitoring</h3><p>Deploying without proper monitoring tools in place is risky because it delays the detection of issues. Ensure that real-time monitoring and alerting systems are active and tailored to detect critical issues in production environments.</p><h3>14. Caving to the HiPPO</h3><p>It is tempting to bend to the HiPPO (Highest Paid Person’s Opinion), but it is critical to understand that they are ultimately just another contributing member just like you. Approach every conversation as a collaboration, where ideas are shared and challenged, and explore all ideas deeply before choosing a path forward.</p><h3>15. Overloading Teams with Urgent Work</h3><p>Constantly assigning high-priority, urgent tasks to your team can lead to burnout, sloppy work, and increased error rates. Balance urgent work with regular maintenance and improvement tasks to keep the team healthy and productive.</p><h3>16. Lack of Backup and Disaster Recovery Plans</h3><p>Relying on the assumption that everything will go smoothly without setting up a robust backup and disaster recovery plan can lead to catastrophic data loss or extended downtime in case of failure. Periodically testing these plans is just as important as having them.</p><h3>17. Allowing “Shadow IT” Systems</h3><p>Developers may sometimes implement unofficial tools or workflows (“shadow IT”) to speed up processes, but these often require a lot of upkeep, and can become risky if they bypass security protocols or are not properly maintained. Ensure all systems and tools used by the team are known, supported, and compliant with organizational policies.</p><h3>18. Overly Aggressive Deadlines</h3><p>Setting unrealistic timelines for project delivery forces engineers to cut corners in testing, reviews, or building a scalable implementation, leading to poor-quality code. Set achievable goals that account for development, testing, and stabilization.</p><h3>19. Not Addressing Security Concerns Early</h3><p>Pushing security considerations to the end of the development process rather than integrating them from the beginning creates vulnerabilities and a frenzy of unplanned work to address issues before a production release. Implement secure coding practices and regular security audits throughout the development lifecycle, and address issues early.</p><h3>20. Allowing Scope Creep Without Reassessment</h3><p>When new features are continuously added to a project without reassessing deadlines and resources, it introduces significant risk. Scope creep can lead to missed deadlines, lower quality, and incomplete features. Ensure scope changes are carefully evaluated.</p><p>If you can address all of these risky behaviors, you are likely to release much more stable, secure, and performant products on a much more reliable basis.</p><p>Paul is a Director of Engineering for <a href="https://www.method.com/">Method</a>, a digital strategy, design, and engineering group building beautiful user-facing experiences. Follow him on <a href="https://www.linkedin.com/in/paulcullenrowe">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3254bfee088" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t Die: Mental Health in Software Engineering]]></title>
            <link>https://prowe214.medium.com/dont-die-mental-health-in-software-engineering-32686621a00b?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/32686621a00b</guid>
            <category><![CDATA[mental-health]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[burnout]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Wed, 12 Apr 2023 15:57:38 GMT</pubDate>
            <atom:updated>2023-04-12T15:57:38.399Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A dog sitting in a room sipping a coffee. The room is currently on fire. He smiles and says “This is fine.” Clearly, this is not fine." src="https://cdn-images-1.medium.com/max/1024/1*a5G0rS8Fii5D0tPmm-tfSQ.jpeg" /><figcaption>Don’t pretend that things are fine.</figcaption></figure><p>I’m sad when I see my friends, my colleagues, and my own reports, burning themselves out in this industry and killing their passion for something they love doing. I’ve even done it to myself a few times.</p><p>We work well when we’re happy and having fun. We work poorly when we’re not. Simple as that.</p><p>Software engineering is hard, with lots of pressure. There’s no need to make it even harder for yourself. The stress will bleed into your work, into your life, into your relationships.</p><p>So here’s the greatest piece of advice I’ve ever received:</p><h3><strong><em>Don’t set yourself on fire to keep everyone else warm.</em></strong></h3><p>You shouldn’t work into the night to get something done by the end of a sprint.</p><p>You shouldn’t work weekends because you feel you’re behind.</p><p>You shouldn’t fill every working minute with additional work just because having a moment to relax gives you anxiety.</p><p>You shouldn’t feel the need to be as fast as your teammate who is a supersonic coder.</p><p>You shouldn’t own the entire burden of your team missing a deadline, even if it was your task that caused the team to miss it.</p><p>You shouldn’t build in a silo if you’re stuck.</p><p>You shouldn’t cause yourself undue mental stress just so the client can do a thing two days earlier.</p><p>You shouldn’t delay that trip you want to take.</p><p>You shouldn’t have much PTO left at the end of the year, if any.</p><p>You shouldn’t worry about taking too many days away at once (your team could probably use some time away from you anyway).</p><p><strong>You are a person, not a machine.</strong><br><strong>You are a responsible adult and can be trusted that you’re doing your best.</strong><br><strong>You need time to breathe, to sleep, to think.</strong><br><strong>Your manager and your team should have your back if you are having difficulty finding that time.</strong></p><p><strong>Book the trip.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/44/0*r-dXBB_sxet9QnMg.png" /></figure><p>Paul Rowe is a Director of Engineering at <a href="http://method.com/">Method</a>, where we strategize, design, architect, and build custom software. Follow him on <a href="https://linkedin.com/in/paulcullenrowe">LinkedIn</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32686621a00b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Proposing Monumental Work Successfully]]></title>
            <link>https://prowe214.medium.com/proposing-monumental-work-successfully-adda2ec632cb?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/adda2ec632cb</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Thu, 09 Feb 2023 00:04:03 GMT</pubDate>
            <atom:updated>2023-02-09T00:04:03.852Z</atom:updated>
            <content:encoded><![CDATA[<p>Yesterday I discovered a <a href="https://github.com/reactjs/reactjs.org/pull/5487#issuecomment-1409720741">Github comment</a> from Dan Abramov that laid out the potential future for <a href="https://create-react-app.dev/">Create React App</a> (CRA), which has been the officially recommended way to spin up a new React app quickly for a long time.</p><p>But now there are lighter, faster, and arguably better tools to do this. <a href="https://vitejs.dev/">Vite</a>, <a href="https://parceljs.org/">Parcel</a>, <a href="https://nextjs.org/">Next.js</a>, <a href="https://remix.run/">Remix</a>, and <a href="https://www.gatsbyjs.com/">Gatsby</a> have all gained ground in the ecosystem for different use cases.</p><p>As a result, CRA is showing its age.</p><p>In summary, the CRA team isn’t ignorant of this. And <a href="https://github.com/reactjs/reactjs.org/pull/5487#issuecomment-1409720741">in the post</a>, Abramov lays out the problems, the opportunities, and five roadmaps they have considered, and based on their research, which direction they’re likely to go.</p><h3>Clear Communication</h3><p><strong>The thoroughness and transparency of that post is what I’m focused on</strong>.</p><p>Because in my opinion, <strong>its a ✨ master class ✨ in proposing monumental work</strong> (and its just an offhand Github comment ironically).</p><p>He’s proposing rearchitecting the tool entirely, which is no small feat.</p><p>To do so, the post:</p><ul><li>Gives a thorough “state of the ecosystem”</li><li>Acknowledges the strengths of market competitors, and chooses to <em>use them</em> rather than try to beat them</li><li>Clearly articulates options, the benefits of each, and how the future of each might play out</li><li>Identifies the most likely path forward</li><li><em>Notes that the team hasn’t started moving on it yet, opting to collect more feedback from the community</em></li></ul><p>Sometimes the tech ecosystem moves faster than our team can incrementally keep up with, or sometimes (in an extreme scenario) we acquire so much tech debt that its better to rewrite. This is a reality of the software development world — it moves fast, and we do what we need to keep up.</p><p>In either case, an overhaul is a scary proposal for stakeholders. So we should make it extremely clear how we come to a decision so that everyone affected can understand.</p><p>Paul is a Director of Engineering for <a href="https://www.method.com/">Method</a>, a digital strategy, design, and engineering group building beautiful user-facing experiences. Follow him on <a href="https://www.linkedin.com/in/paulcullenrowe">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=adda2ec632cb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Code Review Checklist ✅]]></title>
            <link>https://prowe214.medium.com/the-code-review-checklist-3b538194786b?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b538194786b</guid>
            <category><![CDATA[bugs]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Thu, 12 Nov 2020 16:26:17 GMT</pubDate>
            <atom:updated>2020-11-12T16:26:17.718Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/853/1*E9V7MjV9f4Hwt3KzpUQ5iw.jpeg" /><figcaption>Of course, we don’t review code while walking down the hall. Yes, this is staged. There isn’t even coffee in that cup.</figcaption></figure><p>Code review is <strong>the most effective teaching tool</strong> for onboarding team members, upskilling newer developers, and becoming an expert on the product and technology.</p><p>But it isn’t effective if you breeze through it.</p><p>Code Review should take a good amount of time, <strong>longer than you’re probably comfortable with</strong>. The reviewer should understand what is being changed, why, and how it was resolved. Once these are understood, the reviewer can effectively critique the work.</p><p>On my teams, we prioritize quality over speed. Ironically, we often end up delivering faster than teams that prioritize speed — and with significantly fewer bugs.</p><blockquote>Code Review takes a significant amount of time invested up front, but it creates a shared knowledge that eliminates tons of basic mistakes down the line. Ultimately this saves tons of time and effort for everyone.</blockquote><p>Here’s my code review checklist for these teams:</p><h3>✅ Understand the original problem</h3><p>Whether a feature, a bug, or an enhancement, understand <strong>WHY</strong> we are doing this work in the first place.</p><ul><li>Review the work’s ticket (if there is one) and understand the requirements</li><li>Talk to the developer or the reporter if further clarification is needed</li></ul><p>Answer the question: “What’s the problem that this work solves?”</p><h3>✅ Locally replicate the problem</h3><pre>git pull develop<br>npm start</pre><p>Take the branch that the PR branched from, and physically watch the problem occurring.</p><p>When you can see what the problem is, you can diagnose the proper solution more effectively.</p><h3>✅ Understand the required fix or feature</h3><ul><li>Based on what you’ve seen so far, what would you determine are the possible solutions? Try to think of a few options.</li><li>What areas of the code might need work to solve this problem?</li><li>From a UX perspective, is the solution that was proposed in the requirements actually the best way to fix the issue?</li></ul><h3>✅ Review the PR directly (understanding dev’s approach, checking syntax errors)</h3><p>Now we start looking at code. Review the code’s diff in your repository (Github, Bitbucket, etc). This is the easiest way to see the “before and after” of what’s been changed, and the major pieces of the work.</p><ul><li><strong>Is the overall approach a good one?</strong> Is it adding too much complexity? Is it working on the right area of the code?</li><li><strong>If so, are there any basic mistakes?</strong> Syntax errors, poorly named or mistyped variables, extraneous comments, formatting issues, or typos?</li><li><strong><em>MOST IMPORTANTLY</em>: Do you understand <em>everything</em></strong> <strong>about how this code works?</strong> If there’s something you don’t understand, <em>you should add a comment asking for clarification!</em> This will either a) help the developer teach you new tools, or b) help them realize that their code isn’t clear and needs to be cleaner.</li></ul><h3>✅ Locally play with the PR branch</h3><pre># on root branch<br>git pull<br>git checkout the-pr-branch<br>npm start</pre><ul><li>Pull down the code and see the solution in action, explore how pieces are being linked together and how interactions work in the code.</li><li>Try to break the feature again.</li><li>Change some code and see how it changes things.</li><li>See if there are any lingering errors in the console or IDE which need cleanup</li></ul><p>These are all steps you will take to confirm that the code works as expected.</p><h3>✅ Check if unit tests are testing every interaction effectively</h3><p>Every codebase should have unit tests, and those tests should check that every function is working <em>exactly</em> as expected with both “usual” input and “unusual” input.</p><p>Are you actually testing everything you <em>think</em> you’re testing? Code coverage tools like <a href="https://jestjs.io/">Jest</a> or <a href="https://www.sonarqube.org/">SonarQube</a> are easy to implement and can tell you if you are truly testing everything — I personally like a coverage level of 80%.</p><p>For each test:</p><ul><li>Check if the output is correct with good values. Check that function handles bad values gracefully.</li><li>Check that all logic inside of a function is being tested effectively. Is something inside of a function hard to test? <strong>It probably needs to be pulled out into a separate function</strong> and tested separately.</li><li>Check that all unit tests are passing and not throwing odd/unnecessary errors in the test suite.</li><li>Check that your code coverage level has not fallen below the coverage threshold you configured. If it has, add more/better tests where the report identifies weak coverage.</li></ul><h3>✅ When you’ve given feedback, do it all again when changes are pushed</h3><p>You have reviewed one PR, and it probably took a while. Good! But it doesn’t end here.</p><p>When the developer pushes new commits to address the feedback of you or others (fixes and improvements), you should go back and test it again. When small things are changed, it can have a big impact on other areas of the application. Run through the checklist again.</p><blockquote>The code in a PR should always be considered “ready for production”, never accept “I can fix that later”. It should always be reviewed expecting a high quality of delivery.</blockquote><h3>🤔 Conclusion</h3><p>This process takes a while and is intentionally intensive. That’s a good thing!</p><p>When you follow this process:</p><ul><li>Fewer bugs get through</li><li>Developers understand more deeply about the product and learn it MUCH faster</li><li>Reduces the amount of “re-reviews” because — when done effectively — devs learn from each others’ mistakes in other PRs. This dramatically speeds up time that PRs spend “in review”</li><li>The team develops a culture of constant improvement and peer mentorship</li></ul><p>Those are all ultimately goals of every software development team. So put better PR review practices in place, embrace the initial heavier load, and watch your team’s quality of output improve dramatically!</p><p><em>Paul is an engineering manager at </em><a href="http://skookum.com/"><em>Skookum</em></a><em>, a former UI/UX designer, a snowboarder and golfer in Colorado, and apparently a </em><a href="http://prowe214.medium.com/"><em>dev blogger</em></a><em>. Follow me on </em><a href="https://www.linkedin.com/in/paulcullenrowe"><em>LinkedIn</em></a><em>, the </em><a href="https://twitter.com/prowe214"><em>Tweeter</em></a><em>, </em><a href="https://github.com/prowe214"><em>Github</em></a><em>, or anywhere you can find deep snow.</em></p><p><em>Need help building a product or a team? I’ll chat with ya on </em><a href="https://www.linkedin.com/in/paulcullenrowe"><em>LinkedIn</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b538194786b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Privacy around COVID Exposure Notifications (Contact Tracing)]]></title>
            <link>https://prowe214.medium.com/privacy-around-covid-exposure-notifications-contact-tracing-447683bad7a9?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/447683bad7a9</guid>
            <category><![CDATA[colorado]]></category>
            <category><![CDATA[covid19]]></category>
            <category><![CDATA[privacy]]></category>
            <category><![CDATA[contact-tracing]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Tue, 03 Nov 2020 22:37:00 GMT</pubDate>
            <atom:updated>2020-11-03T22:37:00.353Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PdQzuBx7EUF9I2smybEPBA.png" /></figure><p>Colorado just launched their <a href="https://covid19.colorado.gov/Exposure-notifications">“Exposure Notifications” COVID contact-tracing program</a>. It’s a setting you turn on on your phone.</p><p><em>Other states are rolling out similar programs, either using the same setting or a separate app. In this post I’m referring only to Colorado’s, and it should be noted that </em><strong><em>these are only my conclusions based on reading their provided documentation, and could be incorrect.</em></strong></p><p>I’m a privacy nerd, I give talks on the data security and give workshops on improving privacy in software engineering environments.</p><p>There’s a ton of concern around these programs treatment of privacy and the government’s ability to track your movements and your relationships. These concerns are justified.</p><p>So I dug into it — or at least what they made available in every single “learn more” screen and privacy document.</p><p>I went and read EVERYTHING they had.</p><h3>So are they tracking me?</h3><p>It seems like your device sends essentially this data to other devices:</p><pre>// not actual data, just my illustration</pre><pre>someRandomIdentifierKey: &#39;obqn34guinbqwepo4&#39;<br>timeStampOfContact: 3:33pm Oct 31 2020<br>hasBeenExposed: true/false</pre><p>Your identifier key updates every 20min so it can’t be linked to an individual. It should also be noted that it does not send or receive location information ever.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/491/1*xjZpcXR9jMTWrfEyNZZa5g.png" /><figcaption>Actual logs from my device after one day. Someone get me a charger.</figcaption></figure><p>Here’s how it works:</p><p>If you have bluetooth turned on, your phone is always looking for other devices to connect to bluetooth anyway. So this uses that, and it fires off this data to other devices who are opted-in to receive it.</p><p>Every device keeps a list of all keys its logged and their positive/negative, plus all the keys that those keys were in contact with, etc. This list lives only on your phone, is encrypted, and deletes each item after 2 weeks.</p><p>Your phone also keeps track of how long you were near another device and how close you were (based on bluetooth signal strength).</p><p>If someone was exposed (or self-reported a positive test) and then was in contact with you or someone you were in contact with, it notifies you. It also tracks duration of exposure, so it probably won’t notify you if you simply walk past someone on the sidewalk.</p><h4>So should I be concerned?</h4><p>Assuming there’s nothing nefarious under the hood, there are no glaring privacy concerns with this program.</p><p>There is nothing at all that is personally identifiable in the data captured. All it cares about is whether you’ve been exposed to someone who is COVID positive, and notifying you.</p><h4>Should I turn it on?</h4><p>I believe that more data is better data and could save lives in this case, so from a moral standpoint, I say yes.</p><p>For privacy concerns, it passes <em>my</em> smell test. I personally decided to turn on the Exposure Notifications setting on my iPhone. I have not been in contact with anyone lately, so I am pleased to report that I haven’t seen the notification alerting me of exposure.</p><p>If you decide to explore deeper, please let me know if you discover anything interesting or fun!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=447683bad7a9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to 10x Your Speed (For anyone that uses a computer)]]></title>
            <link>https://prowe214.medium.com/how-to-10x-your-speed-for-anyone-that-uses-a-computer-e24bed1fcc2c?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/e24bed1fcc2c</guid>
            <category><![CDATA[10x]]></category>
            <category><![CDATA[efficiency]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[keyboard]]></category>
            <category><![CDATA[speed]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Mon, 19 Oct 2020 14:02:46 GMT</pubDate>
            <atom:updated>2020-11-10T20:25:29.855Z</atom:updated>
            <content:encoded><![CDATA[<h3>3 Tips to 10x Your Speed (For anyone that uses a computer)</h3><figure><img alt="wow such speed" src="https://cdn-images-1.medium.com/max/1024/1*yip9QAxgsH00qvbg4lD4yg.jpeg" /></figure><p>I’ll bet you think you’re fast. I’m going to give you some tips that will make you faster, and you’ll like your computer a whole lot more.</p><p><em>TL;DR — If you read nothing else in this article, the takeaway is to </em><strong><em>reduce your reliance on your point-and-click mouse/trackpad</em></strong><em>, because its slow and often inaccurate.</em></p><h3>1. Ditch your mouse, use keyboard shortcuts for everything</h3><p>Let’s run a quick experiment.</p><p>Type your mailing address into some app. Then when you’re done, without touching the mouse or trackpad, try to spot your mouse on your screen.</p><p>It probably took you a couple of seconds to find it. But while you were typing, you didn’t even think about where those keys were located. They’re always in the same predictable place. <strong>Your keyboard is your fastest way to tell the computer to do something.</strong></p><p>For a simple example: Time yourself hitting Cmd+C, Cmd+V to copy/paste. Now time yourself to Find Your Mouse &gt; Edit &gt; Copy, Find Your Mouse &gt; Edit &gt; Paste. Or even the same with the right-click menu. And that’s not mentioning time lost with missed clicks.</p><p>By using keyboard shortcuts, you save seconds on every action. Those many little seconds add up to many minutes per day, and in a week can add up to hours.</p><h4>Starting today, make every effort to ditch your mouse</h4><p>Keep your hands on your keyboard and don’t let them leave. Be hard on yourself, and only use your mouse if you absolutely can’t figure something out. (You should google that action’s shortcuts and keyboard it next time!)</p><p>This is going to be a very uncomfortable process and you will feel very slow for a week or two. And you’ll have a harder time when surfing websites (but don’t let this deter you, try your best, <em>especially if you’re a software/web developer!</em>)</p><p>Learning this skill will dramatically increase your speed!</p><p>My most-used keyboard shortcuts that people forget (mac):</p><ul><li>In text, <strong>Option+Arrow</strong> — skip to end of word/paragraph. <strong>Option+Delete</strong> deletes whole words too.</li><li>In text, <strong>Cmd+Arrow</strong> — skip to end of line/page. <strong>Cmd+Delete</strong> deletes whole lines too.</li><li><strong>Cmd+Tab</strong> — quickly switch apps</li><li><strong>Cmd+Space</strong> — App/File finder (way faster than navigating through your file system, just start typing the name!)</li><li><strong>Cmd+~</strong> — Next window in the current app (like switching between open word docs)</li><li><strong>Ctrl+Tab</strong> — Next tab in current window (like switching between chrome tabs)</li><li>(For developers) <strong>Learn Vim!</strong> VSCode has a great Vim emulator and it increases your development speed like crazy.</li></ul><h3>2. Only use full-screen or half-screen</h3><p>If your screen looks like this, you might as well get a smaller screen</p><figure><img alt="small window on a large screen = poor window management" src="https://cdn-images-1.medium.com/max/1024/1*SWxFawGKdVrGkxNpBDNlRQ.png" /><figcaption>Figure 01: Small windows on a big screen are wasted space</figcaption></figure><p>Always use ALL of your screen real-estate so that you can see more, do more, and be more productive.</p><figure><img alt="desktop using window management for split screen" src="https://cdn-images-1.medium.com/max/1024/1*ArgzfNWOzVVQxEy1OMorKQ.png" /><figcaption>Figure 02: Using full screen real-estate with two windows via a window manager!</figcaption></figure><h4>How? Use a window manager!</h4><p>Window managers create keyboard shortcuts (ayyyy!) to snap your windows to full screen, half screen, third, quarter, any screen configuration you want, super quickly and easily. No more click and drag because mouse accuracy is slow and difficult.</p><ul><li><a href="https://rectangleapp.com/">Rectangle</a> (easy, free, and successor of the late great Spectacle)</li><li><a href="https://apps.apple.com/us/app/moom/id419330170?mt=12">Moom</a> ($10, lightly-customizable)</li><li><a href="https://folivora.ai/">BetterTouchTool</a> ($9, advanced, more configurable and does way more than just window management)</li></ul><h3>3. Use the desktop app of your web apps</h3><p>Lots of our favorite web apps have desktop apps — Slack, Spotify, Todoist, etc. Sure, their site works great in Chrome, but it gets easily lost in all of your Chrome tabs!</p><p>The desktop app keeps a separate area of concern for each piece of your daily workflow, rather than mashing them all together in your browser. This makes it easy to quickly <strong>Cmd+Tab</strong> to your chats, or your music, or your code editor.</p><p>Plus, most desktop apps come with a few extra features that you can’t get out of the website (including keyboard shortcuts!).</p><p>So go download the desktop app for your daily tools.</p><h4>But my thing doesn’t have a desktop app!</h4><p>😱 <em>Busted!</em></p><p>Just kidding. Things like GSuite, Asana, Trello, and your regularly visited websites, don’t have desktop apps. But there’s a way around that!</p><ul><li><a href="https://tryshift.com/">Shift</a> — Free/$99ann. A desktop app to manage <a href="https://tryshift.com/apps/">hundreds of web apps</a> (that don’t have desktop apps) from one organized place. Check this out for sure.</li><li><a href="https://stationhq.com/">Station</a> — Free. A Chrome extension to quickly navigate to recently visited docs, tabs, sites, apps, and more. I loved their desktop competitor to Shift, but their new extension looks promising.</li><li><a href="https://fluidapp.com/">Fluid</a> — Free/$5. Creates a devoted desktop app for any website. For some sites, this tool can be clumsy, but for many its seamless. Worth a shot if you want a devoted desktop experience.</li></ul><p>— —</p><p>Got more tips and tricks? Drop them in the comments, I’m always learning new ways to get faster!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e24bed1fcc2c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A zsh script to make git squashes easy!]]></title>
            <link>https://prowe214.medium.com/a-zsh-script-to-make-git-squashes-easy-3a68e51ce302?source=rss-7e155dae2bc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a68e51ce302</guid>
            <category><![CDATA[squash]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[zsh]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[version-control]]></category>
            <dc:creator><![CDATA[Paul Cullen Rowe]]></dc:creator>
            <pubDate>Wed, 20 May 2020 23:18:53 GMT</pubDate>
            <atom:updated>2020-05-20T23:18:53.958Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="command line script to squash all commits on a branch" src="https://cdn-images-1.medium.com/max/1024/1*gkx_-EMi3hrLkHaxkixm2w.jpeg" /></figure><p>Keep a clean git source tree and squash your branches before merging!</p><p><strong>This script squashes all commits on your branch.</strong></p><p>When you look at your main branch’s git history, in most development environments it is more useful to just see commits for major changes, not all the little steps and mistakes it took to get there. A <strong>“squash”</strong> in git is the term used for combining past commits together, thereby reducing the amount of commits in your git history.</p><p>In most of my repositories, that means when I’m done building on a feature branch, I squash the branch down to one commit, rebase the feature onto the latest original branch (master, or develop in gitflow), force-push and merge.</p><p>This makes my git history of the main branch only show commits of the finished product of branches!</p><p><em>(Note: Most repository managers like Github and Bitbucket have a “squash and merge” option for merging Pull Requests. This is for those who are not using Pull Requests or do not have that option)</em></p><p>If you use zsh in your terminal (<a href="https://ohmyz.sh/">and you totally should</a>), this simple script will work great for you.</p><p>Copy and paste this into your ~/.zshrc file (I put it just before my aliases are defined):</p><pre>squashon () {</pre><pre>  # If user just enters &#39;squashon&#39;, give help text<br>  if (( # == 0 )); then<br>    echo Hello!  This will squash your current branch down to one unstaged commit.<br>    echo Use by typing squashon rootBranchName<br>    echo usage: squashon develop<br>  fi</pre><pre>  # If a root branch is provided, run the squasher<br>  if (( # == 1 )); then<br>    branch=$(git symbolic-ref HEAD)<br>    echo Squashing all commits from $branch<br>    git reset $(git merge-base $1 $branch)<br>    echo ------SUCCESS!------<br>    echo Commits successfully squashed, all file changes are unstaged.<br>    echo Run &#39;git add -A&#39; and &#39;git commit -m &quot;your commit message&quot;&#39; to add your squashed commit.<br>  fi<br>}</pre><h3>What `squashon` does</h3><p>Assume you have a root branch called ‘develop’, and a feature branch called ‘feature/new-thing’ which originated from ‘develop’. Your feature branch has 10 commits on it, the feature is complete and approved, and it is ready to be squashed!</p><p>Run the script in the terminal with: squashon develop</p><p>This will take all changes you made on your branch, bring you back to the point when you branched off of develop, and keep them as unstaged changes.</p><p>Now just run git add -A &amp;&amp; git commit -m &#39;your commit message&#39; and you’ll have one single commit that includes all of your branch’s changes!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a68e51ce302" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>