<?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[Planet Argon - Medium]]></title>
        <description><![CDATA[Discussions on Rails, UX, design, culture, and more - Medium]]></description>
        <link>https://medium.com/planet-argon-tenets?source=rss----a7d8041c8b3e---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Planet Argon - Medium</title>
            <link>https://medium.com/planet-argon-tenets?source=rss----a7d8041c8b3e---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 10:32:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/planet-argon-tenets" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[PHP2Shell: What We Checked, What We Fixed, and What We Learned]]></title>
            <link>https://medium.com/planet-argon-tenets/php2shell-what-we-checked-what-we-fixed-and-what-we-learned-02da54419e5e?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/02da54419e5e</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[upgrade]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 16:51:10 GMT</pubDate>
            <atom:updated>2026-10-26T16:51:12.131Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OEYu7u4uU3s7WQ8RSzryDg.png" /></figure><p>On Tuesday, October 20, the PHP project gave everyone a day’s notice that a security release was coming for two critical vulnerabilities. On Wednesday, the fixes landed.</p><p>The vulnerabilities, now known as PHP2Shell, are tracked as CVE-2026–109618 and CVE-2026–109619. Both are rated 9.2 out of 10, and both can allow unauthenticated remote code execution. In plain terms, someone on the internet could take control of an affected server with a single crafted request, before any of the application’s own code even runs.</p><p>Most of the applications we support at Planet Argon are built on Ruby on Rails, which isn’t affected. But PHP has a way of showing up where people don’t expect it: a company blog, a marketing site, a content management system running alongside the main application. So we spent the day finding out where it was.</p><h3>Most of the work was checking</h3><p>Most of the applications we work on weren’t impacted because they don’t have WordPress blogs or PHP anywhere in the app. But a few did.</p><p>One application needed a same-day upgrade, one needed a temporary safety net, and a few got light follow-up work.</p><p>Ideally, that’s what a security day looks like: a lot of checking and a short list of fixes. When the list is short, it’s usually because the work was done months earlier.</p><h3>The one that needed real work</h3><p>One client runs a Laravel-based content management system on PHP 8.1. PHP 8.1 reached end of life at the end of 2025, so the PHP project no longer publishes official releases for it. There was no 8.1 patch to install.</p><p>So the fix became a version upgrade, the same day. We moved the application to PHP 8.2.35, the patched release on the oldest branch PHP still supports.</p><p>There was one snag. The official Docker image for 8.2.35 hadn’t been published yet. Rather than wait, the team built the image from PHP’s official build recipe, swapping in the new version. They kept the standard checks that verify the download (checksum and signature), and left extensions and configuration unchanged.</p><p>Then we tested it:</p><ul><li><strong>Locally:</strong> the image built cleanly, extensions loaded, and the application’s install and setup steps ran without errors.</li><li><strong>In the staging environment:</strong> the app, its background worker, and its admin all confirmed running 8.2.35.</li><li><strong>One broken feature:</strong> WebP image uploads failed. Before calling it a regression, we checked the old version. It failed there too, because WebP support had never been built in. The upgrade didn’t cause it, and it’s now on the list.</li></ul><p>Then it went out to production. Fix applied!</p><h3>When you can’t upgrade today</h3><p>Not every team can ship a PHP upgrade on a few hours’ notice. For another client, we turned on Cloudflare’s web application firewall (WAF) protection as a stopgap. Cloudflare had been working with the PHP team ahead of the announcement, and had rules blocking known PHP2Shell attack traffic live about nine hours before the vulnerabilities went public.</p><p>A firewall rule is a safety net, not a fix. Cloudflare says so itself: patch PHP as soon as possible and keep the firewall on as an extra layer. That’s the plan for this client too. But for now, we applied a band-aid.</p><h3>What happens next</h3><p>Patching was the first step. The follow-up work is already underway:</p><ul><li><strong>Extra hardening</strong> on the public-facing side of the upgraded application, based on the mitigations the PHP team published.</li><li><strong>Cleanup:</strong> switching to the official Docker image once it’s published, and clearing out new deprecation warnings that came with 8.2.</li><li><strong>Planning the next upgrade.</strong> PHP 8.2 reaches end of life on December 31, 2026. An application still on 8.2 after that date will be right back where this client was this week: the next vulnerability arrives, and there’s no patch to install.</li></ul><h3>What we’d recommend</h3><p><strong>The patch is only quick if you’re on a supported version.</strong> For applications on supported PHP, this week was a routine update. For the one on 8.1, it was a same-day upgrade project. Same vulnerability, very different day, and the difference was decided long before October 21.</p><p><strong>Know where your PHP lives.</strong> Plenty of teams don’t think of themselves as running PHP. Check the blog, the marketing site, the CMS, and anything a vendor set up years ago.</p><p><strong>Have a stop gap you can turn on.</strong> A firewall layer like Cloudflare’s buys time. It doesn’t replace the upgrade, but it keeps a hard day from becoming a dangerous one.</p><p><strong>Look up your end-of-life dates now.</strong> PHP 8.2 ends December 31, 2026. The same question applies to every language and framework your application depends on.</p><p><strong>Staying current is how proven software keeps going.</strong> We talk a lot about giving existing applications a second act. That doesn’t mean leaving them alone. Keeping the language and framework current is the routine work that lets a fix like this go out in an afternoon instead of turning into a scramble.</p><h3>If you’re on PHP 8.1 or 8.2</h3><p>If your application runs on PHP 8.1 or older, it didn’t get an official release this week. If it’s on 8.2, it has until the end of the year. Either way, we’re happy to help you plan an upgrade, with a firewall stopgap in place if you need time. <a href="https://www.planetargon.com/contact">Let’s talk</a>.</p><h3>Further reading</h3><ul><li><a href="https://cert.europa.eu/publications/security-advisories/2026-018">CERT-EU Security Advisory 2026–018: Critical Vulnerabilities in PHP</a></li><li><a href="https://blog.cloudflare.com/php-vulnerabilities-waf-protection">Cloudflare: Cloudflare deploys protections against php2shell vulnerability</a></li><li><a href="https://sansec.io/research/php2shell">Sansec: PHP2Shell technical writeup</a></li><li><a href="https://news-web.php.net/php.announce/509">PHP: Upcoming Critical PHP Security Release announcement</a></li></ul><p><strong><em>*This was originally published on </em></strong><a href="https://blog.planetargon.com/blog"><strong><em>Planet Argon’s blog</em></strong></a><strong><em>.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=02da54419e5e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/php2shell-what-we-checked-what-we-fixed-and-what-we-learned-02da54419e5e">PHP2Shell: What We Checked, What We Fixed, and What We Learned</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The 2026 Ruby on Rails Community Survey Is Open]]></title>
            <link>https://medium.com/planet-argon-tenets/the-2026-ruby-on-rails-community-survey-is-open-ae1d1ab73161?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/ae1d1ab73161</guid>
            <category><![CDATA[ruby-on-rails-development]]></category>
            <category><![CDATA[rails]]></category>
            <category><![CDATA[surveys]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Wed, 06 May 2026 18:19:35 GMT</pubDate>
            <atom:updated>2026-05-06T18:19:36.724Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*46hG7J6L_3d3DPxmTR0fWg.jpeg" /></figure><p>We’ve been running this survey since 2009. Seventeen years. Nine editions.</p><p>Every two years, we ask the Rails community what’s really going on- not the polished version of how things are going, but the real one. The gems you’ve standardized on. The upgrades you keep pushing off. The parts of the codebases that get avoided. Every response helps complete that picture, and we put it all back in the community’s hands.</p><p><a href="https://railsdeveloper.com/survey/"><strong>Take the 2026 Ruby on Rails Community Survey →</strong></a> <em>Open through July 3. Completely anonymous.</em></p><h3>What we’re asking this year</h3><p>The survey covers everything you’d expect: Ruby and Rails versions, hosting and deployment setups, testing tools, team size, how you learned Rails, and what conferences you’re attending.</p><p>But a few questions this year are worth calling out.</p><p><strong>How is your team using AI tools in your development workflow?</strong> We’re asking because nobody has this data yet. Not the hype version but the real one. Are you regularly using AI tools? Actively experimenting? Evaluated them and decided not to?</p><p><strong>What technical changes are Rails teams planning in the next year?</strong> Consolidating services back into a monolith. Migrating away from Heroku. Adopting Kamal for deployment. Adopting AI agents into development workflows. These are the kinds of shifts we’re tracking, and the answers should tell us a lot about where the community’s priorities are actually landing right now.</p><p><strong>Which JavaScript libraries or frameworks are you using with Rails?</strong> Hotwire. React. htmx. Alpine. Everyone has an opinion. We’re asking so the data can settle a few arguments… or start new ones.</p><h3>Why the results matter</h3><p>We publish everything we learn, free, for the whole community. The results don’t disappear — they become the data point someone else uses to make their case, understand the ecosystem, or just feel less alone in what they’re dealing with.</p><p>The more voices in the data, the more useful it is for everyone who reads it. Including you.</p><h3>One ask</h3><p>Know a Rails developer? Send them the link. The survey runs through July 3.</p><p><a href="https://railsdeveloper.com/survey/"><strong>Add your voice to the 2026 Rails Community Survey</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae1d1ab73161" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/the-2026-ruby-on-rails-community-survey-is-open-ae1d1ab73161">The 2026 Ruby on Rails Community Survey Is Open</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Smart Cuts: How to Audit and Reduce Your Team's Tool Overload]]></title>
            <link>https://medium.com/planet-argon-tenets/smart-cuts-how-to-audit-and-reduce-your-teams-tool-overload-7794308c5090?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/7794308c5090</guid>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 16:41:47 GMT</pubDate>
            <atom:updated>2026-04-15T16:41:48.943Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P-NGDBOn3ymTf0NZmY12sw.jpeg" /></figure><p>If you&#39;ve recently taken a closer look at your team&#39;s monthly expenses, you&#39;re not alone. A lot of companies are finding that they&#39;re spending more than they realized on software tools, subscriptions, and digital services. And while some of these are mission-critical, others may be collecting dust in the background.</p><p>Whether you&#39;re in the middle of budget planning or just trying to clean up your operations, there&#39;s a good chance you&#39;ll spot tools that haven&#39;t been used in months. Knowing what to cut and how to do it without disrupting your team isn&#39;t always straightforward.</p><p>We work with companies that are trying to maximize the value of their <a href="https://www.planetargon.com/services/ruby-on-rails-consulting">existing systems and investments</a>. That often includes helping teams sort through their tech stack and decide what&#39;s worth keeping. This post is a guide for managers ready to start simplifying.</p><h3>Start by Taking Inventory (Not Just Looking at the Budget)</h3><p>The first instinct is usually to open the financial report and look for the largest line items. But that only tells part of the story. The best way to get started is to ask the team what they use and what they like.</p><p>Try this:</p><ul><li>Ask each department or team lead to list the tools they&#39;re using regularly. Weekly and monthly use are good thresholds to start with.</li><li>Compare those lists with what shows up on your billing records.</li><li>Watch for duplicates. Are two teams using different tools to do the same job?</li><li>Don&#39;t forget to include internal tools such as design platforms, analytics dashboards, and any plugins or services that are tied to your development process.</li></ul><p>You&#39;ll probably discover a few surprises. That tool you signed up for last year to run a quick survey? Still billing you. What analytics platform did your team use for one campaign? Quietly running in the background.</p><h3>Be On the Lookout for Hidden Overlap</h3><p>Tool bloat doesn&#39;t always come from big-ticket items. Sometimes, it creeps in when teams grow and individuals bring in their personal preferences or old habits. Documentation is one of the most common areas where this happens.</p><p>We&#39;ve worked with teams that have technical documentation spread across:</p><ul><li>GitHub Wikis</li><li>Confluence</li><li>Notion</li><li>Google Drive</li></ul><p>Each tool was introduced with good intent — maybe by a new engineer, a different agency, or a growing product team — but the result is scattered knowledge and rising costs. Even worse, no one&#39;s quite sure where the &quot;source of truth&quot; lives.</p><p>In cases like this, picking <strong>one central documentation platform</strong> can save money and help everyone stay aligned. Ask your team which tool they like best and cut down from there.</p><p>Another red flag? Tools that solved a real problem years ago, but now feel overly complex compared to what&#39;s needed. We&#39;ve seen clients paying for expensive automation tools or internal dashboards that could now be replaced with:</p><ul><li>A Zapier workflow</li><li>A Google Sheet connected to a form</li><li>A simple webhook or email integration</li></ul><p>The tools you started the company with are most likely not the most modern way to accomplish the task. Don&#39;t be afraid to revisit those decisions.</p><h3>Assign Ownership to Every Tool</h3><p>One reason tools stick around long after they stop being useful is that no one owns them. When responsibility is vague, tools get renewed by default — even when they&#39;re not adding value. A simple way to address this is to assign a single point of contact for each paid tool or service. That person doesn&#39;t need to manage the tool itself, but they should be able to speak to how (and if) the team is using it.</p><p>When someone owns a tool, it&#39;s easier to:</p><ol><li>Review usage regularly</li><li>Make a recommendation about keeping, downgrading, or canceling</li><li>Track license counts and reduce unnecessary seats</li><li>Know who to check with before making changes</li></ol><p>This type of ownership helps avoid unnecessary renewals and opens up conversations about alternatives that might better serve your team- something we often explore through <a href="https://www.planetargon.com/services/code-audit">maintainability-focused audits</a>.</p><h3>Be Thoughtful About What You Cut</h3><p>Not every unused tool can (or should) be removed right away. Even if something isn&#39;t actively used, it may still be connected to your workflows, store important data, or support occasional but critical tasks.</p><p>Before you remove a tool, ask:</p><ul><li>Is anyone using this tool behind the scenes?</li><li>Does it store any data we&#39;ll need later?</li><li>Is it connected to other systems or automated processes?</li><li>If we turn this off, what breaks?</li></ul><p>If you&#39;re unsure, it&#39;s always a good idea to involve your technical team or your development partner. For example, if you&#39;re considering removing a dev tool or deployment service, a quick conversation with the engineering team can prevent accidental downtime or broken integrations.</p><p>Sometimes, the best first step is to reduce rather than remove. You may be able to downgrade a subscription tier or reduce the number of unused seats, which can still result in significant savings.</p><h3>Make It a Process, Not a One-Time Clean Up</h3><p>When tools get cut without context, it can make people feel like resources are being taken away. But when tool reviews are part of a regular process, it becomes less about budget and more about alignment.</p><p>Here are a few ways to make this part of how your team works:</p><ul><li><strong>Communicate clearly:</strong> Let your team know you&#39;re reviewing tools to streamline and focus, not just to cut costs.</li><li><strong>Involve the right people:</strong> Don&#39;t just cancel a tool based on usage stats. Ask the folks who use it how it fits into their workflow.</li><li><strong>Set a review schedule:</strong> Quarterly reviews make it easier to spot tools that have outlived their usefulness.</li></ul><p>When teams see that tool changes are thoughtful and collaborative, they&#39;re more likely to buy into the process and suggest their own ideas for what to remove or improve.</p><h3>Wrapping Up</h3><p>Cleaning up your tool stack doesn&#39;t have to be disruptive. With a bit of coordination and a focus on what&#39;s actually being used, you can simplify your systems, save some budget, and help your team stay focused on what matters.</p><p>If your team is looking to simplify, document better, or revisit tools that may be overkill for what you need today, the team at Planet Argon has been through it. <a href="https://www.planetargon.com/work">We&#39;ve helped clients</a> transition from scattered systems to streamlined setups that are easier to manage and more cost-effective. It&#39;s not about doing more with less — it&#39;s about doing the right things with what you already have.</p><p><a href="https://blog.planetargon.com/blog/entries/smart-cuts-how-to-audit-and-reduce-your-teams-tool-overload"><strong>This post was originally shared on Planet Argon&#39;s blog.</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7794308c5090" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/smart-cuts-how-to-audit-and-reduce-your-teams-tool-overload-7794308c5090">Smart Cuts: How to Audit and Reduce Your Team&#39;s Tool Overload</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Cost of Leaving a Software Rewrite “On the Table”]]></title>
            <link>https://medium.com/planet-argon-tenets/the-cost-of-leaving-a-software-rewrite-on-the-table-967b5a49706e?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/967b5a49706e</guid>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[rails]]></category>
            <category><![CDATA[ruby-on-rails-development]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Wed, 01 Apr 2026 16:09:30 GMT</pubDate>
            <atom:updated>2026-04-01T16:09:31.953Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n-GS5vgBsO7vesyuJj5eeQ.jpeg" /></figure><p>There’s a pattern we keep running into.</p><p>We hear it in conversations with engineering teams. It shows up in <a href="https://maintainable.fm/">podcast interviews</a> with people who’ve lived through multiple generations of <em>“the next system.”</em> It comes up in hallway track conversations at conferences. And it surfaces when experienced engineers quietly start exploring new roles and struggle to explain, cleanly, what went wrong.</p><p><em>“We might rewrite this someday.”</em></p><p>Different companies. Different stacks. Same dynamic.</p><p>By the time teams reach out to us, they’re often at an inflection point. They’re debating whether to rewrite software they are entirely reliant on, even though it still runs the business every day. The system might be built with Rails, Ember, or something else entirely. It reflects years of real-world tradeoffs, customer pressure, and survival decisions. Some of those decisions still make sense. Some don’t. What matters is that the software works… and the team’s relationship to it has quietly deteriorated.</p><p>Once the idea of a rewrite enters the room, even casually, progress starts slowing long before anything actually breaks.</p><h3>How Rewrite Talk Becomes a Drag on Momentum</h3><p>Most teams never actually decide to rewrite their software. There’s no announcement. No budget. No timeline. No explicit mandate.</p><p>Instead, the idea hovers.</p><p>It shows up as banter. A half-joke in Slack. A comment in a meeting. “Honestly, we’ll probably rewrite this someday.” No one disagrees. No one commits either. The rewrite becomes a shared possibility rather than a plan.</p><p>For leaders, this is easy to miss because nothing has officially changed. But psychologically, everything has.</p><p>Once something is treated as provisional, people stop taking full responsibility for it. Not out of apathy. Out of self-preservation. When engineers believe the system is temporary, they invest less in it. They stop fixing small things. They stop deepening their understanding. They stop improving quality-of-life issues that don’t obviously pay off right now.</p><p>They’re still doing their jobs.<br>They’re just doing them in a waiting posture.</p><p>That posture shows up in subtle but compounding ways. Refactors get deferred. Tests feel less urgent. Documentation falls behind. Deep fixes only happen when they’re unavoidable. Engineers stop advocating for improvements when they no longer believe improvements are expected or valued.</p><p>From the outside, this can look like a lack of motivation or resistance to change. From the inside, it feels like professional disengagement. Deploys feel riskier. Reviews become more conservative. Ownership blurs. The team isn’t blocked by the codebase… they’re blocked by uncertainty about whether the work they do today will matter tomorrow.</p><h3>Asking About a Rewrite Is Healthy. Leaving It Unresolved Is Not.</h3><p>It’s worth saying clearly: it <em>is</em> healthy for teams to ask whether a rewrite is warranted periodically. Avoiding the question entirely is not stewardship. Systems age. Context changes. Sometimes replacement really is the right move.</p><p>The problem isn’t asking the question.</p><p>The problem is asking it informally, repeatedly, and never finishing the thought.</p><p>What we see most often is that teams do explore the rewrite question and land on the most common conclusion: staying put is the least risky, most pragmatic option right now. And then… nothing happens. No rationale gets written down. No decision gets shared. No alternative path is named clearly.</p><p>So the conclusion evaporates, even though the outcome remains.</p><p>That’s how rewrite fantasies linger.</p><p>A year later, someone new joins the team and makes an offhand comment: “Well, once we rewrite all this…” And unless someone responds clearly, the cycle restarts. The team slips back into provisional thinking, even though a decision was already made.</p><p>When a team decides not to rewrite, that decision needs a spine. It should be captured, shared, and reinforced. It should name the risks that were evaluated, explain why replacement wasn’t the right move, and clearly state what the team <em>is</em> committing to instead.</p><p>That doesn’t shut down discussion.<br>It shuts down drift.</p><h3>Why This Pattern Shows Up So Reliably</h3><p>I wrote about this more explicitly in a post describing the <a href="https://robbyonrails.com/articles/2025/09/20/seven-stages-of-tech-stack-adoption/">seven stages of tech stack adoption</a>. The goal wasn’t to define a perfect lifecycle, but to name a familiar arc that appears once software survives long enough to matter.</p><p>Early on, teams feel momentum and optimism. The system is small, understandable, and easy to change. As the product succeeds, pressure increases. Guardrails appear. Process grows. Tradeoffs accumulate. Over time, the software becomes more capable… and heavier.</p><p>Eventually, many teams reach a stage where the system still works, but changing it feels slow, risky, or emotionally exhausting. That’s usually when rewrite talk begins to surface.</p><p>Not because the software is failing.<br>But because the team is tired.</p><p>For product and technical leaders, this framing can be useful. Instead of asking whether the technology is “too old,” it’s worth asking where your team would place itself along that arc. Are they engaged and investing? Cautious but confident? Or resigned and waiting?</p><p>Rewrite talk often shows up as a symptom of that last stage.</p><h3>Why AI Forces This Question to the Surface</h3><p>There’s an accelerant in the room right now: AI.</p><p>Many leaders are understandably looking at new tooling and thinking, “We can finally move faster. Maybe this is the moment to rebuild.” It’s not irrational to ask the question. If AI can reduce friction and speed up delivery, then yes, this is a reasonable time to re-evaluate big bets.</p><p>But this is where teams get tripped up.</p><p>AI makes it easier to <em>start</em> things. It does not remove the hardest parts of a rewrite. It doesn’t untangle domain complexity. It doesn’t migrate data safely. It doesn’t reproduce years of edge cases. It doesn’t eliminate the cost of running two systems in parallel during the organization’s transition.</p><p>If a team already carries an unspoken “someday we’ll rewrite” vibe, AI pours fuel on it. Not because it changes the fundamentals, but because it offers a convenient story. A way to avoid stewardship while still sounding ambitious.</p><p>And if the team doesn’t answer the rewrite question themselves, someone else will. At some point, a product leader, executive, or board member will ask, “If AI makes us faster, why aren’t we rewriting this? Your team doesn’t even seem excited to maintain what we have.”</p><p>That question is coming. The best move is to get ahead of it.</p><h3>How Leaders Can Reset the Dynamic</h3><p>Instead of rushing to justify a rewrite, the more effective move is to change the questions being asked.</p><p>Questions like:</p><ul><li>Are we treating this software as something we actually inhabit?</li><li>What daily friction has the team normalized?</li><li>What improvements keep getting postponed because they’re not “strategic” enough?</li><li>If nothing changed for a year, what would burn people out first?</li></ul><p>These surface behavior and experience, not architecture.</p><p>One exercise we’ve seen work well is to ask the team to assume this is the <em>last production codebase they will work in for the remainder of their careers</em>. No rewrite. No replacement. Just stewardship. Then ask what they would fix first to improve quality of life, what frustrations they would finally address, and what they would stop tolerating.</p><p>The answers are rarely about frameworks. They’re about clarity, safety, and reducing unnecessary stress. Those answers are usually a better roadmap than any rewrite proposal.</p><h3>A Final Reframe</h3><p>Leaving a software rewrite “on the table” isn’t neutral.</p><p>It shapes behavior.<br>It lowers standards.<br>It teaches teams to wait.</p><p>Ask the rewrite question. Take it seriously. Do the analysis. But <strong>when you decide to stay put, say it out loud.</strong> Capture the rationale. Repeat it. Point to what has improved since.</p><p>What stalls teams isn’t old software.<br>It’s unresolved futures.</p><p>And the <a href="https://www.planetargon.com/second-act">second act</a> doesn’t start with new code.<br>It starts when leaders help their teams fully re-inhabit the systems they already depend on every day.</p><p><a href="https://blog.planetargon.com/blog/entries/the-cost-of-leaving-a-software-rewrite-on-the-table"><strong><em>This post was originally published on Planet Argon’s blog.</em></strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=967b5a49706e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/the-cost-of-leaving-a-software-rewrite-on-the-table-967b5a49706e">The Cost of Leaving a Software Rewrite “On the Table”</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Resourcing and Coordination Basics: A CEO’s Guide to Onboarding a Development Agency]]></title>
            <link>https://medium.com/planet-argon-tenets/resourcing-and-coordination-basics-a-ceos-guide-to-onboarding-a-development-agency-a8f9143f3b20?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/a8f9143f3b20</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[onboarding]]></category>
            <category><![CDATA[partnerships]]></category>
            <category><![CDATA[ceo]]></category>
            <category><![CDATA[agency]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Wed, 14 Jan 2026 14:42:06 GMT</pubDate>
            <atom:updated>2026-01-14T14:42:09.862Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YPBcNJZxrNUla3zsy-PWqA.jpeg" /></figure><p>Bringing in a development agency is often less about speed and more about trust. You’re inviting new people into a system that already has history, context, and real-world consequences tied to it.</p><p>When the relationship is meant to last, how you start matters just as much as what you build together. Clear rhythms, shared ownership, and a little upfront coordination can turn an external team into a true extension of your own.</p><p>Based on our work in <a href="https://www.planetargon.com/services/rails-support-maintenance-retainer">long-term partnerships</a>, here are four areas that make the biggest difference early on.</p><h3>1. Set a Communication Schedule with the New Agency</h3><p>One of the first decisions you’ll make with your new development agency is how often — and how intentionally — you’ll communicate. In long-term retainers, communication is key to sustaining momentum for the team between your company and the new agency.</p><ul><li><strong>Start with a structured cadence:</strong> We recommend setting up weekly calls between your internal point of contact and our Project Manager. These are for reviewing progress, prioritizing tasks, and surfacing any blockers.</li><li><strong>Use async updates for daily visibility:</strong> Whether it’s Slack or Jira, create space for quick, daily updates. This helps avoid bottlenecks and keeps progress visible.</li><li><strong>Clarify tool usage:</strong> Ensure everyone knows where to find tickets (e.g., Jira, Trello), documentation (Confluence, Github Wiki), and communication threads.</li><li><strong>Maintain transparency:</strong> If goals shift or scope expands, surfacing that in a regular forum helps us recalibrate the plan early, not scramble later.</li></ul><p>Communication is the one “non-technical” lever that most strongly impacts velocity in the first 60 days of a project.</p><h3>2. Assign a Key Contact to Maximize Your Relationship</h3><p>Even with strong communication channels, there’s no substitute for a single, empowered point of contact on your side. This person becomes the translator of priorities, the keeper of the roadmap, and the unblocker-in-chief.</p><p>In our model, you’ll typically be in regular contact with a <strong>dedicated Project Manager</strong> and a <strong>Lead Engineer</strong>, so having someone on your side who mirrors that level of involvement is crucial.</p><ul><li><strong>Choose someone with context and decision-making authority:</strong> ideally, they understand the product vision and technical constraints and have the authority to approve scope or budget changes.</li><li><strong>Avoid fragmented ownership:</strong> When multiple voices direct the agency, priorities get muddied, and timelines drift. Agencies thrive when we know who to go to and what success looks like.</li><li><strong>Ensure responsiveness:</strong> Agencies like ours operate on agile principles. Questions and clarifications come up mid-sprint, and delays in response can stall momentum.</li><li><strong>Champion the relationship:</strong> The more your internal point of contact treats us as partners rather than vendors, the more strategic value we can return.</li></ul><h3>3. Developer Resourcing: Understand It in Days, Not Just Headcount</h3><p>It’s tempting to ask, “How many developers do I get?” But headcount alone doesn’t tell the whole story. At Planet Argon, we prefer to talk in <strong>developer days per week, </strong>a clearer way to manage effort and expectations.</p><p>A typical team on your account may include:</p><ul><li>A <strong>Lead Engineer, </strong>often a senior Ruby on Rails dev with deep product experience.</li><li>One or more <strong>support engineers</strong> based on complexity and velocity needs.</li><li>An <strong>Engineering Manager</strong> who steps in as needed to resolve complex or architectural issues.</li><li>A <strong>Project Manager</strong> who meets with you regularly, ensuring the team stays on track.</li></ul><p>Why developer days matter:</p><ul><li><strong>They create clarity:</strong> Knowing you have 3 or 5 dev-days/week allows for better sprint planning and budget tracking.</li><li><strong>They help you scale up/down:</strong> Need to accelerate a launch or reduce budget in Q4? You’re planning in measurable units.</li><li><strong>They show progress early:</strong> Once we track how much is completed per dev-day, we can estimate delivery timelines more reliably.</li><li><em>Tip: Don’t hesitate to ask how the team is resourced. Transparency breeds trust, and it allows you to plan ahead.</em></li></ul><h3>4. Planning “The Big Push” for a New Feature</h3><p>Every application has its “launch moments,” a major feature release, an important demo, or a marketing campaign tied to the product roadmap. When working with an external development team, planning these pushes is about <strong>coordination, not just coding</strong>.</p><p>Because Planet Argon builds long-term relationships, we often help clients pace and plan these launches, not just execute them.</p><p>Here’s how to get it right:</p><ul><li><strong>Lock the scope early:</strong> As early as possible before the release, define what “must be done” versus “nice to have.” We’ll help pressure-test the plan.</li><li><strong>Use a sprint buffer:</strong> Always build in 1–2 extra weeks for QA, polish, or last-minute changes. Big launches rarely go 100% to plan.</li><li><strong>Loop in non-development teams early:</strong> If this feature ties to a campaign, customer training, or stakeholder review, brief them upfront.</li><li><strong>Set clear definitions of done:</strong> Beyond functionality, this includes <a href="https://blog.planetargon.com/blog/entries/debugging-with-test-driven-development">test coverage</a>, documentation, and possibly <a href="https://blog.planetargon.com/blog/entries/what-is-a-staging-environment-and-why-do-we-need-one">staging</a> or analytics setup.</li></ul><p>Big launches aren’t just about speed — they’re about precision. With shared planning, we reduce the chaos and maximize impact.</p><h3>Final Thoughts: Great Relationships Start with Great Coordination</h3><p>When you hire a development agency like Planet Argon, you’re not just hiring engineers, you’re entering a partnership. Our <a href="https://www.planetargon.com/services/rails-support-maintenance-retainer">retainer-based model</a> is built for long-term collaboration, but its success depends on the fundamentals: clear communication, empowered points of contact, thoughtful resourcing, and collaborative planning.</p><p>By aligning on these basics early, you don’t just accelerate delivery — you unlock the full value of an embedded dev team that grows with your business.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8f9143f3b20" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/resourcing-and-coordination-basics-a-ceos-guide-to-onboarding-a-development-agency-a8f9143f3b20">Resourcing and Coordination Basics: A CEO’s Guide to Onboarding a Development Agency</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Legacy App Modernization: A Case Study in Rails 8 and Rapid Prototyping]]></title>
            <link>https://medium.com/planet-argon-tenets/legacy-app-modernization-a-case-study-in-rails-8-and-rapid-prototyping-ed4ef2fc7691?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/ed4ef2fc7691</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[business-development]]></category>
            <category><![CDATA[legacy-code]]></category>
            <category><![CDATA[hotwire-rails]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Wed, 07 Jan 2026 20:19:18 GMT</pubDate>
            <atom:updated>2026-01-07T20:19:17.530Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gcxo8qXeT6M8wBXNt6Gu0Q.png" /></figure><p><strong><em>The database wasn’t failing. The business was just moving faster than it could keep up.</em></strong></p><p>Our client, a leading roofing contractor, faced significant challenges with their aging Microsoft Access database application. While once effective, the legacy system had become a bottleneck for their growing business operations. Key pain points included:</p><ul><li>An outdated technology stack that limited scalability and modern feature implementation.</li><li>Slow and inefficient workflows that impacted daily operations.</li><li>Limited ability to integrate with modern business tools and services.</li><li>Growing concerns about data security and system reliability.</li></ul><p>Recognizing these challenges, we proposed a comprehensive modernization strategy. The approach was to build a rapid prototype, validating the technical solution before committing to full-scale development. This strategy allowed us to work through quick feedback and ensured the solution met the client’s needs.</p><p>The engineering team chose a modern, robust technology stack:</p><ul><li><a href="https://edgeguides.rubyonrails.org/8_1_release_notes.html">Ruby on Rails 8.0.1</a>: The latest version of Rails, providing a mature, battle-tested framework with modern features</li><li><a href="https://github.com/ruby/ruby/releases/tag/v3_4_1">Ruby 3.4.1</a>: Taking advantage of the latest Ruby performance improvements and features</li><li><a href="https://native.hotwired.dev/">Hotwire</a> (Turbo + Stimulus): For building dynamic, SPA-like experiences without the complexity of a JavaScript framework</li><li><a href="https://blog.getbootstrap.com/2023/09/14/bootstrap-5-3-2/">Bootstrap 5.3.2:</a> For a responsive, professional UI that works across all devices</li><li><a href="https://www.postgresql.org/">PostgreSQL</a>: A powerful, reliable database system</li><li><a href="https://kamal-deploy.org/">Kamal</a>: For streamlined, containerized deployment</li><li><a href="https://aws.amazon.com/s3/">AWS S3</a>: For secure, scalable file storage</li></ul><p>This technology stack was chosen specifically for its ability to deliver rapid development cycles, <a href="https://maintainablerails.com/">maintainable code</a>, and a modern user experience while ensuring long-term scalability and reliability. Combining Rails 8’s latest features with Hotwire’s modern approach to frontend development allowed the team to build a sophisticated application without the complexity of a separate JavaScript framework.</p><p>The solution was designed to be deployed using modern DevOps practices, with containerization through Docker and deployment automation via Kamal, ensuring consistent and reliable deployments across environments. This approach modernized the application and set up our client for future growth and technological advancement.</p><h3>Building a Prototype Quickly</h3><p>When we began building the prototype, our primary goal was to create a functional application that validated our technical approach while providing immediate value to the client. We focused on delivering the most critical features first, knowing we could expand the functionality in the full development phase.</p><p>The prototype included several key features that were essential for daily operations. Service reports were a top priority, allowing the team to document their work and generate professional PDF reports. We implemented a comprehensive image management system that supported uploading, rotating, and organizing photos of roof conditions and repairs. A particularly important feature was the ability to mark specific points on roof images, which helped the team identify and document areas that needed attention or had been previously repaired.</p><p>For the administrative side, we built a role-based system that controlled access to different features. This included permissions for creating and editing forms, exporting PDFs, and managing user accounts. The system was designed to be flexible, allowing various access levels for administrators, office staff, and field employees.</p><p>Before writing any code, we made several critical technical decisions. We chose PostgreSQL as our database, which would provide the reliability and performance needed for the application. We implemented AWS S3 integration for image storage, ensuring photos would be securely stored and easily accessible. The PDF generation system was built using Prawn, allowing us to create professional-looking reports with the company’s branding.</p><p>The development process started with setting up the basic Rails 8 application and configuring the development environment. We then built the core models and controllers to handle the different forms and images. The user interface was built using Bootstrap 5, providing a clean and responsive design that worked well on desktop and mobile devices.</p><p>We deliberately left some features for the full development phase. These included Progressive Web App (PWA) capabilities, Google Maps integration for roof overviews, and digital signature functionality. This approach allowed us to deliver a working prototype quickly while gathering feedback from the client.</p><p>The prototype demonstrated that our technical approach was sound and that the application would meet the client’s needs. It provided a solid foundation for the full development phase while giving the client a clear picture of how the final application would work.</p><h3>Rails 8: A Modern Foundation</h3><p>One of the most exciting aspects of this project was the opportunity to work with Rails 8, the latest version of the framework. Rails 8 significantly improves performance, security, and the developer experience, making it an excellent choice for modernizing applications.</p><h3>ActiveStorage: Robust File Management</h3><p><a href="https://guides.rubyonrails.org/active_storage_overview.html">ActiveStorage</a> played a crucial role in our prototype, particularly for handling the extensive image management requirements. We implemented a sophisticated image handling system that includes:</p><ul><li><strong>Flexible Storage Backend:</strong> Using AWS S3 for production and local storage for development, ActiveStorage provided a seamless way to manage file uploads across different environments.</li><li><strong>Image Variants:</strong> We leveraged ActiveStorage’s variant system to create optimized versions of images for various use cases, including thumbnails and previews.</li><li><strong>Custom Image Rotation:</strong> We implemented a custom image rotation system that allows users to rotate images in 90-degree increments, with the changes persisted to the storage backend.</li><li><strong>Content Type Validation:</strong> Added validation to ensure only JPEG and PNG files are accepted, maintaining data quality and security.</li></ul><p>The implementation was particularly elegant, with a concern-based approach that made the image handling functionality reusable across different models:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/467/0*0sAhxIvXcGwcuy4i.png" /></figure><h3>Stimulus: Enhancing User Interactions</h3><p>Stimulus proved an excellent choice for adding JavaScript behavior to our application. We used it to create several interactive features:</p><ul><li><strong>Form Handling:</strong> Created a form controller that manages dynamic form behavior, including image previews and validation feedback.</li><li><strong>Image Marking System:</strong> Implemented a sophisticated image marker controller that handles the placement and management of markers on roof diagrams.</li><li><strong>Role-Based UI:</strong> Used Stimulus to dynamically show/hide form elements based on user roles, improving the user experience.</li></ul><p>The Stimulus controllers were lightweight and focused, following the framework’s philosophy of enhancing HTML rather than replacing it. We kept the HTML structure in our views and used JavaScript to add behavior to it, rather than generating the entire UI from JavaScript. For example, our image marker controller:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/467/0*hk8iVaK3SYMHTeLe.png" /></figure><h3>Hotwire: Seamless Updates</h3><p><a href="https://blog.planetargon.com/blog/entries/hotwire-for-rails-developers-keeping-ui-fast-and-maintainable">Hotwire</a>, particularly Turbo, was instrumental in creating a smooth, app-like experience without the complexity of a full single-page application (SPA). We used it in several key areas:</p><ul><li><strong>Form Submissions:</strong> Implemented Turbo Streams for form submissions, providing instant feedback without full page reloads.</li><li><strong>Status Updates:</strong> Used Turbo Frames to update form statuses in real-time.</li><li><strong>Image Previews:</strong> Created dynamic image previews that update immediately after file selection.</li></ul><p>The combination of Turbo and Stimulus allowed us to create a responsive application that feels modern and fast, while maintaining the simplicity and reliability of server-rendered HTML. For example, our form status updates:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/467/0*s36YQ2NXwDW-XZW1.png" /></figure><p>This modern stack, comprising Rails 8, ActiveStorage, Stimulus, and Hotwire, provided a powerful foundation for building a robust and user-friendly application. The combination of these technologies allowed us to deliver a prototype that met the client’s requirements and provided a solid foundation for future development.</p><h3>Kamal — Simplifying Deployment</h3><p>When it came time to deploy our prototype to a production environment, we needed a solution that would be quick to set up, reliable, and easy to maintain. Enter Kamal, a deployment tool that perfectly suited our needs for getting the application up and running on an EC2 instance.</p><h3>Why Kamal?</h3><p>For our prototype phase, Kamal offered several key advantages:</p><ol><li><strong>Quick Setup:</strong> With just a single configuration file, we could define our entire deployment stack, including the application, database, and environment variables.</li><li><strong>Docker-Based:</strong> Kamal uses Docker containers, ensuring consistent environments between development and production.</li><li><strong>Zero-Downtime Deployments:</strong> Built-in support for zero-downtime deployments, crucial for a production application.</li><li><strong>Simple Rollbacks:</strong> Easy rollback capability if we needed to revert to a previous version.</li></ol><h3>Our Kamal Configuration</h3><p>Here’s a simplified version of our <strong>config/deploy.yml</strong> that shows how we configured the deployment:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/0*dXVkyqBRfUZYaFV9.png" /></figure><h3>Perfect for Prototyping</h3><p>Kamal was particularly well-suited for our prototype phase for 4 big reasons:</p><ol><li><strong>Rapid Deployment:</strong> We could deploy changes quickly with a single command: bin/kamal deploy</li><li><strong>Built-in Monitoring:</strong> Easy access to logs and application status</li><li><strong>Database Management:</strong> Automatic PostgreSQL setup and management</li><li><strong>Environment Variables:</strong> Secure handling of sensitive credentials</li></ol><h3>What’s Next?</h3><p>As we transition from prototype to full development, we’re continuing to use Kamal but with some enhancements:</p><ul><li><strong>Multiple Environments:</strong> We’re setting up staging and production environments</li><li><strong>Automated Deployments:</strong> Integrating with our CI/CD pipeline</li><li><strong>Enhanced Monitoring:</strong> Adding more comprehensive logging and monitoring</li><li><strong>Backup Strategy:</strong> Implementing regular database backups</li></ul><p>The beauty of Kamal is that it grows with your application. What started as a simple deployment solution for our prototype has become a robust deployment platform that will serve us well throughout the project’s lifecycle.</p><h3>Conclusion: From Prototype to Full Development</h3><p>The prototype phase of the <a href="https://www.olssonroofing.com/">Olsson Roofing</a> application rewrite has been a resounding success. The client was particularly impressed with how quickly we delivered a functional application that addressed their core needs. The combination of Rails 8, Hotwire, and Kamal allowed us to move at an unprecedented pace while maintaining high quality and reliability.</p><h3>Client Success</h3><p>The client’s response to the prototype has been overwhelmingly positive. They were able to:</p><ul><li>Test the core functionality in a real-world environment</li><li>Provide valuable feedback on the user interface and workflow</li><li>Validate the technical approach and architecture</li><li>See immediate value in the modernized system</li></ul><h3>Moving Forward with Full Development</h3><p>We’re now in full development mode, building on the success of the prototype. The prototype has served as an excellent foundation, allowing us to:</p><ol><li><strong>Validate Technical Decisions:</strong> Our choice of Rails 8, Hotwire, and Kamal has proven to be the right stack for this project.</li><li><strong>Identify Priority Features:</strong> The prototype helped us understand which features would deliver the most value first.</li><li><strong>Establish Development Patterns:</strong> We’ve established efficient image handling, form management, and deployment patterns.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed4ef2fc7691" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/legacy-app-modernization-a-case-study-in-rails-8-and-rapid-prototyping-ed4ef2fc7691">Legacy App Modernization: A Case Study in Rails 8 and Rapid Prototyping</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing Commit Goods: Official Merch for the Open Source Community]]></title>
            <link>https://medium.com/planet-argon-tenets/introducing-commit-goods-official-merch-for-the-open-source-community-55240b26ea12?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/55240b26ea12</guid>
            <category><![CDATA[open-source-software]]></category>
            <category><![CDATA[community]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[merchandise]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Thu, 27 Nov 2025 15:24:56 GMT</pubDate>
            <atom:updated>2025-11-27T15:24:56.544Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0K9e5xXL6ScP_lXtjFnEtA.jpeg" /></figure><p>Open source runs the world, but the people who keep it running rarely get the spotlight they deserve. We’re launching <a href="https://commitgoods.com/"><strong>Commit Goods </strong></a>to change that.</p><p>Commit Goods is a new merch shop built in collaboration with open source maintainers. Every product is designed with the project leads and shares revenue directly with the folks who keep your favorite tools alive.</p><p>This isn’t just a merch store. It’s a way to support the maintainers who support all of us.</p><p>We’re also currently running our Black Friday sale: 15% off everything in <a href="https://commitgoods.com/">the shop</a>. Use the code <strong>COMMITGOODSLAUNCH</strong>.</p><h3>Lending a Hand</h3><p>If you’ve worked in tech long enough, you know that behind every polished product is an open source project running quietly under the hood. And behind <em>that</em> is a maintainer debugging at midnight, answering issues between meetings, and merging PRs before the rest of us wake up.</p><p>These maintainers build the backbone of the internet. But most don’t have the time, energy, or resources to build an online shop, handle fulfillment, manage customer questions, or promote merch to the wider community.</p><p>That’s where our experience comes in.</p><h3>Back to Our Roots</h3><p>When Robby was a teenager, he built his very first website because <a href="https://www.youtube.com/watch?v=d4Z4ccwfVhM&amp;t=13s">he wanted to sell stickers online</a>. That teenage experiment eventually became the official <a href="https://ohmyz.sh/">Oh My Zsh</a> shop, a small side project that grew into thousands of orders, mugs, tees, stickers, and more over the last thirteen years.</p><p>Running that shop taught us how to handle things like fulfillment and customer support, product design and vendor management, the rhythms of selling merch to a global OSS community, and the reality that even a small shop requires a surprising amount of ongoing work</p><p>Robby observed firsthand that several other open source project maintainers wanted to sell themed stickers and tees, but probably didn’t have the bandwidth to run a shop. We realized that since we already had the infrastructure, the process, the experience, and the audience, we could reach out to some of our favorite OSS maintainers and see if they’d be interested in collaborating with us. We could create the merch designs together and share in the revenue.</p><h3>The Good Things About the Goods</h3><p>Most maintainers can’t justify spinning up a full store. However, their communities would love to wear their logos, represent their brand, and support the project.</p><p>Commit Goods bridges that gap:</p><p><strong>Maintainers get</strong><br>• Custom design support<br>• An official storefront<br>• Shared profits<br>• Less overhead and zero logistics</p><p><strong>Communities get</strong><br>• High-quality, officially approved merch<br>• A way to support the projects they rely on<br>• Fun, thoughtful products that feel true to each tool</p><h3>What We’re Commit(ed) to</h3><p>Commit Goods is an official merch shop built <em>with</em> open source maintainers, not around them. Every design is created in collaboration with the project creators/leads, so nothing is bootlegged. We pair all of that with a retro-computer aesthetic and a community-first philosophy to make gear that feels authentic, ethical, and genuinely fun to wear.</p><h3>Meet the projects in our first collection</h3><p>Our first collection features some of the open-source projects we know and love:</p><p>🔍 <a href="https://openswag.shop/collections/fzf"><strong>fzf</strong></a>. The fuzzy finder we can’t live without.<br>👻 <a href="https://openswag.shop/collections/ghostty"><strong>Ghostty</strong></a>. A fast, modern terminal with a retro soul.<br>🌀 <a href="https://openswag.shop/collections/oh-my-zsh"><strong>Oh My Zsh</strong></a>. The legendary terminal framework that started it all.<br>⚡ <a href="https://openswag.shop/collections/redux"><strong>Redux</strong></a>. The predictable state container powering countless apps.<br>💚 <a href="https://openswag.shop/collections/vue-js"><strong>Vue.js</strong></a>. The progressive framework loved by front-end developers everywhere.</p><p>Each project collaborated with our team to create unique merch like tees, mugs, stickers, hats, and more, reflecting their individual personalities and communities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5eYJZWL1UNA3BmNQ.jpg" /></figure><h3>For Maintainers: Wanna Join a Future Collection?</h3><p><a href="https://commitgoods.com/">Commit Goods</a> is built for you.</p><p>If you maintain an open source project and want to help shape a curated collection for your community, reach out at <a href="/service/mailto:crew@commitgoods.com">crew@commitgoods.com</a> with your project name and a link where we can learn more. We’d love to talk.</p><p>We’re already planning upcoming collections and would be excited to support more maintainers, small projects, big projects, and anything with a community behind it.</p><h3>For the Community: Wanna Support Your Favorite Tools?</h3><p>The first collection is now live at <a href="https://commitgoods.com/"><strong>commitgoods.com.</strong></a></p><p>Don’t forget, we’re offering <strong>15% off everything</strong> from Black Friday (November 28, 2025) through Cyber Monday (December 1, 2025) with the code <strong>COMMITGOODSLAUNCH</strong>.</p><p>We believe open source projects deserve celebration, visibility, and support. Commit Goods is one small way to make that happen. See you in the shop!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55240b26ea12" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/introducing-commit-goods-official-merch-for-the-open-source-community-55240b26ea12">Introducing Commit Goods: Official Merch for the Open Source Community</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Managing Tech Debt with a Custom VS Code Extension]]></title>
            <link>https://medium.com/planet-argon-tenets/managing-tech-debt-with-a-custom-vs-code-extension-ed8c5e19da84?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/ed8c5e19da84</guid>
            <category><![CDATA[legacy-code]]></category>
            <category><![CDATA[tech-debt]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[vs-code-extensions]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Wed, 23 Jul 2025 23:58:04 GMT</pubDate>
            <atom:updated>2025-07-23T23:58:04.379Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7eDLsq_JXWuHqQNIkAelyA.jpeg" /></figure><p>The Planet Argon engineering team has always faced a common but annoying challenge when tackling technical debt management — when an engineer spotted a refactor opportunity during their coding sessions, they would have to create Jira tickets to track it manually. Switching back and forth from VSCode to Jira like that created several problems for our team:</p><ul><li><strong>Context Loss</strong>: Important details such as file location, line numbers, and the actual code snippet were frequently omitted when creating tickets for tracking tech debt.</li><li><strong>Workflow Disruption</strong>: Developers had to switch between VS Code and Jira, breaking their focus and reducing productivity.</li><li><strong>Inconsistent Documentation</strong>: Technical debt items varied greatly in quality and detail without a standardized process.</li></ul><p>We needed a solution that would integrate directly into our development environment and streamline the entire process of capturing and documenting technical debt.</p><h3>Our Solution: Cherrybomb VS Code Extension</h3><p>To bridge this gap, we built Cherrybomb, a custom VS Code extension designed specifically to capture technical debt at the moment of discovery. Here’s why we’re excited about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iWwgmn8i97W7QqE0.jpg" /></figure><p>We started with a <strong>status bar integration</strong> that remains visible whenever VS Code is open. This gives developers a constant, unobtrusive reminder that they can quickly flag technical debt. When they spot problematic code, they simply highlight it and click the status bar icon.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/307/0*h5HfZFx5bA_EfX2V.png" /></figure><p>Behind the scenes, Cherrybomb immediately performs <strong>automatic context capture</strong>, collecting the selected code snippet, the file path, and exact line numbers. This ensures no critical information is lost.</p><p>The extension then displays an <strong>interactive webview form</strong> within VS Code that includes:</p><ul><li>A dropdown menu populated with our active Jira projects.</li><li>Fields for the issue title and description.</li><li>A preview of the captured context information.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/0*vs4PphaNpLppJudz.png" /></figure><p>When the developer submits the form, Cherrybomb authenticates with our Jira Cloud instance and creates a new comprehensive Jira issue that contains all the information collected in the IDE as well as a via-cherrybomb label that makes it easy to filter and find these issues later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CPQjTEyQNQWPIgX0.png" /></figure><p>We packaged the extension as a VSIX file and distributed it internally via a secure file-sharing system. This lets our team install and use it without having to publish it to the public VS Code extension marketplace.</p><h3>Transforming How We Handle Technical Debt</h3><p>Implementing Cherrybomb transformed our approach to technical debt in several ways.</p><p>The most immediate benefit was the elimination of context switching. Developers could now document technical debt without leaving VS Code, letting them keep their focus and create tech debt issues when they have the most context and understanding of the problem.</p><p>The quality of our documentation also improved. Every issue now includes precise code snippets, exact file locations, and line numbers. This makes future fixes more efficient, even when addressed by different team members.</p><p>Our standardized reporting structure has also improved how we prioritize technical debt across projects. Team leads can now make more informed decisions about which issues to address in upcoming sprints based on consistent, detailed documentation.</p><p>The impact on team productivity has been significant:</p><ul><li><strong>Time Savings</strong>: Developers spend less time on administrative tasks and more time writing quality code</li><li><strong>Enhanced Collaboration</strong>: Clear, contextual issue tracking has improved communication between team members</li><li><strong>Knowledge Sharing</strong>: Detailed technical debt tickets serve as learning opportunities for newer team members</li></ul><h3>The Evolution of Cherrybomb</h3><p>While Cherrybomb has already made a substantial impact on our workflow, we see several opportunities for enhancement:</p><p><strong>Feature Expansion</strong></p><ul><li>Adding more formatting options to the webview form for richer issue descriptions</li><li>Integrating additional Jira data fields like fix versions and custom labels</li></ul><p><strong>Integration Improvements</strong></p><ul><li>Connecting with other internal tools to create a more comprehensive technical debt management system</li><li>Adding Git integration to capture branch names and automatically update associated Jira issues when code snippets or branches change</li><li>Enhancing error reporting and handling for a smoother user experience</li></ul><p><strong>User-Driven Refinement</strong></p><ul><li>Ongoing collection of feedback from our engineering team to identify friction points</li><li>Iterative UI improvements based on real-world usage patterns</li></ul><h3>Small Tools, Big Impact</h3><p>Cherrybomb demonstrates that committing to solving very specific workflow problems can have outsized effects on your team’s productivity and code quality. By embedding technical debt management directly into the development environment, we not only improved our documentation and saved time, but we also built our values of code quality and thoughtful refactoring into our devs’ workflows. The success of this project has also inspired us to look for other aspects of our development process that could benefit from similar streamlining.</p><p>Did this helpful little tool solve all of our tech debt or dev workflow problems? Of course not. But sometimes the most effective improvements aren’t huge sweeping platform changes or introducing new processes. Sometimes, all it takes is building a focused tool that removes specific friction points from everyday workflows.</p><p>If you’re interested in how we help clients tackle technical debt and improve their development workflows, check out our case studies on<a href="https://www.planetargon.com/work/walkenhorst-s"> Walkenhorst’s</a>,<a href="https://www.planetargon.com/work/i-will-teach-you-to-be-rich"> I Will Teach You to Be Rich</a>, and<a href="https://www.planetargon.com/work/newspaper-club"> Newspaper Club</a>. Each illustrates our commitment to building maintainable, efficient systems.</p><p><strong>**This article was originally published on Planet Argon’s blog.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed8c5e19da84" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/managing-tech-debt-with-a-custom-vs-code-extension-ed8c5e19da84">Managing Tech Debt with a Custom VS Code Extension</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build a Better AppSignal Dashboard in 10 Minutes]]></title>
            <link>https://medium.com/planet-argon-tenets/build-a-better-appsignal-dashboard-in-10-minutes-f9f30fef25b3?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/f9f30fef25b3</guid>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[webinar]]></category>
            <category><![CDATA[error-handling]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Thu, 17 Jul 2025 20:00:03 GMT</pubDate>
            <atom:updated>2025-07-17T20:00:03.517Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b4ZbUDzc5QkFdh9sXM10OA.jpeg" /></figure><p>Ever feel like your monitoring dashboard is trying to tell you <em>everything</em> — and in doing so, tells you <em>nothing</em>?</p><p>Out of the box, AppSignal gives you a lot: charts, dashboards, graphs, error reports. And for most apps, that’s a great start.</p><p>But if you’ve ever tried to track down an issue in a live app quickly, you know how hard it is to separate real signals from the noise. What you really need is focus.</p><h3>The problem: You’re tracking everything, which means you’re not seeing anything</h3><p>In a recent project, our team struggled to gain clear, actionable insights into a particularly critical section of the app. Sure, the data was there — somewhere—but we were spending more time sifting than solving.</p><p>The issue wasn’t AppSignal. It was how we were using it.</p><h3>🛠️ The solution: Custom dashboards that surface what actually matters</h3><p>Instead of hunting through a dozen charts to find what we needed, we took a step back and built a <strong>custom AppSignal dashboard</strong> tailored to the part of the app we actually care about.</p><p>We:</p><ul><li>Identified the key metrics we check most often</li><li>Added just those charts to a clean, dedicated dashboard</li><li>Set up alerts tied directly to those metrics (not the default noise)</li></ul><p>Suddenly, it wasn’t about digging through clutter — it was about seeing <em>exactly</em> what we needed at a glance.</p><p>The best part? AppSignal makes it super easy to create dashboards from existing graphs or even from scratch. A few clicks, a clearer brain, and way faster response times.</p><h3>👀 Want to see it in action?</h3><p>We’ll be walking through the full process in the first episode of <strong>Planet Argon LIVE</strong>, our new developer-focused webinar series with Michael Kurt, our Software Delivery Manager. We’ll include real code and setup tips that you can use right away!</p><p>🗓 <strong>Wednesday, July 23</strong><br> ⏰ 10 AM, PST<br> 📍 <a href="https://www.linkedin.com/events/planetargonlive-appsignalforapp7349105373443739650/theater/">Watch it live on LinkedIn</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cxxBwqnYPwYRs6-_xlXjlQ.jpeg" /></figure><p>If you’re tired of dashboard overload and want to get straight to the good stuff, this talk’s for you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9f30fef25b3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/build-a-better-appsignal-dashboard-in-10-minutes-f9f30fef25b3">Build a Better AppSignal Dashboard in 10 Minutes</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Organizing the Chaos: Why Password Managers Make Developer Onboarding Easier]]></title>
            <link>https://medium.com/planet-argon-tenets/organizing-the-chaos-why-password-managers-make-developer-onboarding-easier-535c66737ea5?source=rss----a7d8041c8b3e---4</link>
            <guid isPermaLink="false">https://medium.com/p/535c66737ea5</guid>
            <category><![CDATA[onboarding]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[management]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Autumn]]></dc:creator>
            <pubDate>Wed, 09 Jul 2025 17:07:32 GMT</pubDate>
            <atom:updated>2025-07-09T17:07:32.515Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hSdJfTMD2w-vIMvi5XzWvw.jpeg" /></figure><p>Most modern applications rely on a growing collection of credentials: API keys, database logins, cloud service accounts, and environment-specific secrets. Without a consistent system, these critical details often end up buried in email threads, spreadsheets, or old Slack messages.</p><p>That slows everything down — and increases the risk of something going wrong.</p><p>That’s where password managers come in.</p><p>A secure, team-friendly password manager is the foundation of <strong>password management for dev teams</strong>. It helps store and share sensitive credentials in a structured, accessible way. This isn’t just about staying secure — it’s about improving <strong>developer onboarding</strong> and enabling better collaboration.</p><p>When clients already have a system for managing <strong>application secrets</strong>, we can hit the ground running. We don’t have to track down one-off logins or guess which version of an API key is still active. It also reduces the risk of security issues caused by unclear access practices.</p><p>We use — and recommend — <a href="https://1password.com/">1Password</a> because it’s well-suited for teams and offers features like shared vaults, tagging, and command-line access. However, whether you’re using 1Password, <a href="https://bitwarden.com/">Bitwarden</a>, or another provider, the key is having a consistent and secure setup that your team will actually use.</p><h3>Best Practices We Recommend to Clients</h3><ul><li><strong>Use a shared password manager</strong> with role-based access control, allowing team members to view only the information they need.</li><li><strong>Organize secrets by environment or system</strong> — e.g., “Stripe — Live Secret Key” or “Staging — Database Password.”</li><li><strong>Include notes or metadata</strong> like where each secret is used, when it was last rotated, or if it’s tied to a specific user.</li><li><strong>Create a dedicated onboarding vault or folder</strong> to streamline access for new developers or vendors.</li></ul><p>When clients follow these practices, our team can onboard faster, troubleshoot more effectively, and reduce the time spent going back and forth over missing credentials. It’s a small shift that has a big impact on your <strong>technical onboarding for Rails applications</strong>.</p><h3>Making SSH Access Less Painful (and More Secure)</h3><p>SSH keys are a staple of developer workflows, especially when working with remote servers, Git repositories, or deployment pipelines. However, for many clients, managing these keys can be a challenge, particularly when multiple people need access or when security best practices (like rotating keys) are not yet in place.</p><p>Password managers with developer-friendly features — like 1Password — make SSH key management significantly easier.</p><p>Your team can:</p><ul><li>Store private and public key pairs securely in a shared vault</li><li>Label them clearly with context, like prod-deploy-key or staging-ssh</li><li>Add notes to explain what the key is used for and who it’s shared with</li></ul><p>For developers, this simplifies the workflow of accessing a server or Git repo. But it gets even better.</p><p>If you’re using 1Password, the built-in SSH agent allows developers to authenticate using their keys <strong>without having to copy or manually manage them locally</strong>. This means:</p><ul><li>No .pem files floating around</li><li>No risky copy/paste moments in terminal windows</li><li>No forgetting where the key was stored in the first place</li></ul><p>It’s a small but powerful way to improve <strong>secure environment setup</strong> and reduce the risk of human error.</p><h3>One CLI to Rule Them All</h3><p>Beyond SSH, developers often need to access environment variables, secrets, and configuration values when setting up their local development environment. Password managers with CLI support — like op for 1Password—allow <strong>developers</strong> to <strong>retrieve</strong> those secrets from the terminal securely.</p><p>Here’s what that could look like in practice:</p><pre># Fetch a Stripe API key securely from the vault<br>op item get &quot;Stripe – Live Secret Key&quot; --field &quot;password&quot;</pre><p>Or even better — inject values into your .env file on the fly:</p><pre>eval $(op inject -i .env.template -o .env)</pre><p>Why does this matter?</p><ul><li>Developers don’t have to dig through vaults or ask for secrets</li><li>Secrets aren’t stored in plain text on disk</li><li>It’s easier to rotate credentials without breaking everyone’s setup</li></ul><p>We often recommend that clients store a .env.template in their codebase with placeholder values that can be resolved via CLI tools. It’s a cleaner, more secure way to manage <strong>shared secrets for software teams</strong>, especially during onboarding or environment transitions.</p><h3>Developer Happiness is a Security Feature</h3><p>When developers struggle to access the things they need, they tend to find workarounds. Screenshots of passwords in Slack. Personal copies of .env files. Shared Dropbox folders with SSH keys.</p><p>It’s not malicious — it’s just what happens when the tools are clunky or the process is unclear.</p><p>By giving developers secure, easy-to-use tools to manage their environment, you reduce the risk of bad habits forming. More importantly, you make <strong>developer onboarding</strong> feel smooth, professional, and thoughtful. That’s something your internal team (or external partners like us) will notice right away.</p><h3>Final Thoughts: Set It and Forget It (Kind Of)</h3><p><strong>Credential management</strong> is one of those invisible infrastructure tasks that only becomes visible when something breaks. Taking the time to get it right — by using a shared password manager, organizing credentials cleanly, and adopting CLI tools — pays off over and over again.</p><p>From our perspective, the biggest win is the <strong>reduction in friction</strong>. When you bring us in to help with your app, the faster we can access the right systems and tools, the sooner we can start solving real problems.</p><p>You don’t have to go all-in overnight. Start by choosing a password manager your team feels good about (we use and recommend 1Password), create a few shared vaults, and document your process. That alone will make your next <strong>technical onboarding for Rails applications</strong> feel 10x smoother, for everyone involved.</p><h3>🔍 Not sure where to start?</h3><p>We offer onboarding reviews and application audits to help identify gaps in your current setup. From access control to <strong>secure environment setup</strong>, we’ll give you clear, actionable recommendations to make onboarding safer and faster for your team (and ours).</p><p>👉 <a href="https://www.planetargon.com/services/code-audit">Learn more about our audit services</a>.</p><p><em>This post originally appeared on the </em><a href="https://blog.planetargon.com/blog/entries/organizing-the-chaos-why-password-managers-make-developer-onboarding-easier"><em>Planet Argon blog</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=535c66737ea5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/planet-argon-tenets/organizing-the-chaos-why-password-managers-make-developer-onboarding-easier-535c66737ea5">Organizing the Chaos: Why Password Managers Make Developer Onboarding Easier</a> was originally published in <a href="https://medium.com/planet-argon-tenets">Planet Argon</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>