<?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[Technology @ Airtasker - Medium]]></title>
        <description><![CDATA[We come from different places, distinct cultures and a nexus of crazy and complex people, but under one unified battle cry we forge forward as tribe Airtasker! - Medium]]></description>
        <link>https://medium.com/airtribe?source=rss----2469b1fab74c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Technology @ Airtasker - Medium</title>
            <link>https://medium.com/airtribe?source=rss----2469b1fab74c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 20:11:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/airtribe" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[From idea to first sale in nine days, with AI]]></title>
            <link>https://medium.com/airtribe/from-idea-to-first-sale-in-nine-days-with-ai-8de3831cc155?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/8de3831cc155</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Chaitanya Kuber]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 00:51:36 GMT</pubDate>
            <atom:updated>2026-07-22T01:08:33.851Z</atom:updated>
            <content:encoded><![CDATA[<h4>Most engineering blog posts about AI, talk about the tooling. This one is about a shipped product, a real customer, and a calendar.</h4><p><strong>In late May 2026 we had an idea</strong> for a new membership for the tradespeople and businesses who work through Airtasker: Pro Pass, a prepaid annual membership that drops their service fee to zero up to a cap. <strong>Nine working days after</strong> the first product brief was written, <strong>a real customer paid for one</strong> and the product is live on airtasker.com.</p><p>We want to be precise about that number, because round claims invite eye-rolls. <strong>Nine working days</strong> <strong>is</strong> <strong>from the first draft of the product requirements to the first paying customer</strong>. Two of the days in that window were company non-working days, so the calendar stretch was a fortnight. The point is not the trophy. The point is what made it possible, because we think it is now repeatable, and AI is the reason.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SpzZRbZt-LWfc7sf9M7L1w.png" /></figure><h3>The interesting part is not that it was fast</h3><p>To be clear, this was a sprint, and it felt like one. There was real pressure to ship, because the only evidence that would tell us anything was whether someone would actually hand over money for this product. So we are not pretending there was no crunch.</p><p>What made the difference was where the pressure was pointed. The team was given the leeway to drop other work and focus on this one idea. A small group made the product decisions, and AI carried most of the mechanical load of turning those decisions into shipped, reviewed, production code. What we shipped was a deliberate MVP, so there were intentional shortcuts, but they were shortcuts in scope, not in our quality bar.</p><p>Here is how AI actually showed up, end to end.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_LEplGhz3lqtE4CHx9TdYg.png" /></figure><h3>It started as a conversation, and AI wrote it up as the brief</h3><p>The product was not born in a document, rather it started as a discussion in a Slack channel. A small senior group of leaders who could actually decide, working out the offer, the constraints and what to leave out, in among everything else going on that week. That is where the real thinking happened, and like most real decisions it was scattered across a long, messy thread.</p><p>Rather than have someone sit down afterwards and reconstruct all of that by hand, we had Claude analyse the conversation. Guided by a set of skills we have built in-house, it read the thread, pulled out the decisions and the open questions, and drafted a structured requirements document, inferring the shape of the product from how the discussion had actually gone. A person then reviewed and corrected it, the way you would edit any first draft.</p><p>It is worth pausing on that. The very first artefact, the requirements themselves, was AI-assisted. The loop did not begin at the code. It began by turning a conversation into a brief, which is usually one of the slowest and most thankless steps between an idea and a build.</p><h3>AI drafted the plan, then we reviewed it like code</h3><p>Once the requirements were clear, the implementation plan was AI-drafted: the layers it would touch, the sequence of changes, the database design, the deployment order, and a ticket breakdown. That plan went up as a pull request and was reviewed the way we review code, with engineers arguing about the design in the comments.</p><p>That review changed the design, which is the whole point of putting a plan up for review before it becomes code. A reviewer pushed back on the first approach, the trade-off was handed back to the model to weigh the options against our existing systems, and the team landed on a simpler path that reused what we already had rather than building something new alongside it. Less new code, and less risk to a live system. The fast path and the safe path turned out to be the same path, and we found it because the design was written down early and argued over in the open rather than discovered halfway through the build.</p><h3>AI wrote the code, in small reversible pieces</h3><p>The feature was built through around a dozen small pull requests under one epic, each shipped to production on merge. Each one was additive and behaviour-identical for the existing flow, and the single riskiest change landed last on a base that was already safe. Much of that code was written with Claude Code. Because the product was scoped to reuse what we already had rather than build alongside it, the genuinely new surface area was small, which is exactly what made it quick to build and safe to ship.</p><p>Small, additive, reversible changes are what let a payments system move quickly without anyone holding their breath. AI is very good at producing exactly that kind of change, at a pace a human typing alone cannot match.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pRd3dyk1oDUYsmWX6hmwxQ.png" /></figure><h3>AI also reviewed the code, and caught what a quick read would miss</h3><p>This is the part we did not expect to matter as much as it did. Alongside human code-owner review, we run Claude as an automated reviewer on pull requests. An engineer tags it, and it reads the change and comments.</p><p>On one of these pull requests it spotted a genuine concurrency risk, a check-then-write race that a quick read would likely have skated past. It also did the harder part well: it judged the risk non-blocking for that change and recommended closing it later with a database-level constraint rather than application code. Catching the issue is useful. Scoping it correctly, knowing what to fix now and what to log as a follow-up, is the part that builds trust in an automated reviewer.</p><h3>Speed did not mean lowering the bar</h3><p>It would be easy to read all this as corners cut when opposite is true. Every PR went through our full continuous integration suite, security scanning, high test coverage and human code-owner approval. The legal terms were a hard gate we did not move, and finance had an auditable trail from the first sale.</p><p><strong>We went fast by doing less, not by checking less.</strong> The product scope deliberately left whole features for later stages, each named up front, so that the first version could be the smallest thing that genuinely worked.</p><h3>What we think this means</h3><p>We are treating this as a glimpse of how we want to build by default, not a one-off. The shape is simple to describe and hard to fake: a small senior group that can decide quickly, a brief written early and staged honestly, a strong bias to reuse over reinvention, and AI agents drafting the plan, writing the code and running a first-pass review, inside the same quality gates we have always held.</p><p>The headline that AI helped us ship in nine days is the easy story. The one we care about is the slow, mechanical middle of software delivery, the part between a clear decision and a reviewed change in production, is collapsing. <strong>When that middle gets cheap, the work that is left is judgement: what to build, what to leave out, and what good looks like.</strong> That is the work we want our engineers spending their days on, and it is where we are pointing the next year of how we build.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UoG4VJ1iJ62UQBPmJRlLfg.png" /></figure><h3><strong>We will share more as we go. This is the start of a deliberate shift, not the end of one.</strong></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8de3831cc155" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/from-idea-to-first-sale-in-nine-days-with-ai-8de3831cc155">From idea to first sale in nine days, with AI</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Analytics Engineering to Data Platform Engineering]]></title>
            <link>https://medium.com/airtribe/analytics-engineering-to-data-platform-engineering-246d11e01ee9?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/246d11e01ee9</guid>
            <dc:creator><![CDATA[Cooper White]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 01:44:19 GMT</pubDate>
            <atom:updated>2026-07-10T01:44:17.877Z</atom:updated>
            <content:encoded><![CDATA[<p>I joined Airtasker in January of 2024 as an Analytics Engineer — I joined a team of individuals who spent their working week deep in the business problems, building Data Models in dbt to meet their requirements. We were heavy into Kimball Data Modelling, making sure our data tests were on point, and all the other key points associated with the craft. Our stack was built in the peak of the Modern Data Stack ZIRP days, and that stack was popular for a reason- it allowed data teams to focus on the business side of the craft while having reliable (and at the time, cheap!) tooling backing them up handling the platform side of things.</p><p>My official starter project was to build financial data models for incentive redemptions, however that quickly fell to the side as I was given a project to audit some legacy GCP cloud infrastructure, then migrate our CI runners from CircleCI to dbt Cloud, then look at deploying some ML Models in Sagemaker.</p><p>Over the following few years, so much has changed. The ZIRP is long gone and platform prices have gone up. Airtasker has grown as a marketplace, meaning we have more data, meaning more spend. We have built new products, decommissioned old products, and built tooling that uses our Data Warehouse as a source, all things that add complexity. Last, but definitely not least, the huge changes occurring with Agentic Ways of Working (both for development and data consumption), which is evolving the way we create and distribute business value. All of these things have incrementally pushed the Analytics Engineering teams day to day work into managing the Data Platform, whether that’s to decrease costs, increase throughput, or enable new levers for growth.</p><p>As such, we made the active decision to not just maintain this platform as a consequence of our work, but as a first class citizen of Airtasker’s infrastructure. We, as of now, have decided to actively invest in creating a Core Data Platform for all, rather than a BI centric stack with other things tacked on.</p><p>With these changes, I thought that it might be interesting to document the work that we do over the coming 12 months and into the future. Not only for sharing our learnings internally, but to contribute to the broader community.</p><p>The tenets of the new team are based upon the following observations:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FTDfmH_YI2TACpQVpunkvw.png" /></figure><p>These observations each invite a myriad of answers, some fit-for-purpose and some not — and for us some are clearer than others. However, when you start looking into any one of these observations in depth, you land on the same overarching theme: we need a Core Data Platform.</p><h3>So what is the Core Data Platform?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9HX0t7R-8LNq2boI919qLQ.png" /></figure><p>At its simplest: we’re carving a canonical core of business entities — Task, User, Offr, Payment and others — out of our BI pipelines, and treating it as a product in its own right.</p><p>That core has explicit contracts at its edges. Producers commit to what they deliver, consumers commit to what they depend on, and the platform owns the stability of everything in between. That contracted surface is what lets a small team serve a growing set of consumers across BI, ML, CRM, support, and increasingly agents, and enabling our colleagues to build great things without hand-holding each one. It also shrinks the surface any single change touches: cheaper CI, safer changes, and a blast radius small enough for an agent (or a human) to actually reason about.</p><p>So… that’s what we are setting out to build. A smaller, well-defined, contracted core is cheaper to run, safer to change, and a far better launchpad for everything built on top of it, including the data products the rest of the business now wants to build for themselves. It doesn’t only allow leverage for our consumers, but allows great safety and iteration speeds for our producers (plenty of cool stuff going on there too!)</p><h3>What’s next</h3><p>This is an introductory post into what I hope is to become a broader series of architecture and design articles written by myself and our team documenting our journey, starting with an overview of our architecture decision for how we shape these data models.</p><p>Data strategy &lt;&gt; Data tooling, so we will try and do a fair job of discussing both!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=246d11e01ee9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/analytics-engineering-to-data-platform-engineering-246d11e01ee9">Analytics Engineering to Data Platform Engineering</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[We Built a Bot That Does the First 10 Minutes of Every Incident For You]]></title>
            <link>https://medium.com/airtribe/we-built-a-bot-that-does-the-first-10-minutes-of-every-incident-for-you-5ada06e9294e?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/5ada06e9294e</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[sre]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[incident-response]]></category>
            <dc:creator><![CDATA[Asher Moore]]></dc:creator>
            <pubDate>Mon, 23 Mar 2026 21:09:48 GMT</pubDate>
            <atom:updated>2026-03-23T21:09:48.237Z</atom:updated>
            <content:encoded><![CDATA[<p>Most incidents at Airtasker start the same way.</p><p>Engineer gets paged, heart rate spikes, opens Slack, finds the channel. Then the scramble begins:</p><ul><li>Open Datadog… wait which dashboard? Let me search…</li><li>Okay found it, now what’s actually alerting?</li><li>Let me check the traces… build a query… wait wrong time window</li><li>Pull up logs… what’s the right filter again?</li><li>Was there a deploy? Tab over to GitHub…</li><li>Who even owns this service? Let me check the catalog…</li><li>Is there a runbook? <em>searches Confluence</em> …probably outdated anyway</li><li>Any feature flags changed? Open Statsig…</li></ul><p>Eight browser tabs deep and still no clear picture of what’s broken. Ten minutes gone, just gathering context before anyone can start thinking about the actual problem.</p><p>The information exists. It’s scattered across half a dozen tools that were never designed to talk to each other, and nobody’s going to build that integration because it’s not anyone’s core job.</p><p>So we built it ourselves.</p><h3>What We Actually Wanted</h3><p>In those first few minutes of an incident, it’s always the same questions:</p><ul><li>“What’s broken?”</li><li>“When did it start?”</li><li>“Did anything change recently?”</li><li>“Who owns this thing?”</li><li>“Has this happened before?”</li></ul><p>Simple questions. But answering them means logging into five different tools and correlating timestamps in your head while half-asleep at 2am with your phone still buzzing.</p><p>What if engineers could just ask? Type a question into Slack and get an actual answer, not a link to a dashboard they have to interpret themselves. That was the idea anyway.</p><h3>The Human Side of This</h3><p>There’s something else that motivated this project that’s harder to quantify.</p><p>Incidents are stressful. A lot of that stress comes from the chaos of those first few minutes when everyone’s scrambling to understand what’s even happening. But there’s another thing I have noticed: junior engineers sitting silently in incident channels, wanting to help but feeling useless because they didn’t know which dashboard to check or how to build the right Datadog query.</p><p>They are hesitant to ask basic questions and slow things down. This gives them a way to contribute immediately. Ask the bot, get context, share it in the channel. Suddenly they’re participating.</p><p>That’s not a metrics-driven justification. But it matters to me personally.</p><h3>What the Bot Does</h3><p>Two interfaces.</p><p><strong>The slash command: </strong>/incident_help payments-api</p><p>This is “tell me everything” mode. Health metrics, error rates, service dependencies, recent deploys, active feature flags, who owns it. We were ruthless about formatting here. During an incident nobody’s reading paragraphs. The goal is five-second skimmability.</p><p><strong>The @mention: </strong>@clanker what&#39;s the error rate for auth-service?</p><p>Conversational mode. Ask questions in plain English, get answers. It maintains thread context so follow-ups work naturally.</p><p>Under the hood it’s Claude running through AWS Bedrock. We went with Bedrock over calling Anthropic directly for the same reason we use it for Claude Code: data sovereignty. The bot’s ingesting logs and traces and incident details. That stuff should stay in our AWS account.</p><p>It connects to Datadog, Jira, Confluence, GitHub, Statsig. When someone asks something, it figures out where to look, grabs the data, correlates it, and answers.</p><h3>Why We Split It Into Multiple Agents</h3><p>The obvious approach would be giving Claude access to every tool and letting it figure things out.</p><p>We tried that. The token costs were bad. Every tool definition, every API response, every conversation burns tokens. When you’re passing around verbose Datadog query results, it adds up fast.</p><p>So we split it into specialised agents. One that only knows Datadog stuff: metrics, logs, traces, incidents. One for Jira. One for Confluence. GitHub. Web search. Each agent has a narrow set of tools and a focused system prompt.</p><p>An orchestrator routes questions based on keywords. “Deploy” goes to the GitHub agent. “Runbook” goes to Confluence. “Error rate” goes to Datadog. Simple pattern matching, nothing fancy, but it’s fast and it works. Trying to get an LLM to classify questions reliably was more hassle than it was worth.</p><p>Multiple agents can run in parallel if the question spans domains. Token usage dropped by 50–80% depending on query type.</p><p>Press enter or click to view image in full size</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hgjL3lGRrtkhCcNf.png" /></figure><p>Each agent doesn’t just make one API call. It runs an agentic loop of up to eight iterations where Claude decides what data it needs, makes the relevant queries, gets the results back, and decides whether it has enough information to answer or needs to dig deeper. After a few iterations, we start nudging it to wrap up, and at eight, we force a summary from whatever it’s gathered. We also trim older query results from the conversation as it goes to keep token usage under control. This means a single question like “what’s causing errors in payments-api?” might result in the Datadog agent querying metrics, then checking traces, then pulling logs for a specific timeframe it identified, all autonomously within those eight iterations.</p><h3>Things That Were Harder Than Expected</h3><p><strong>Metric naming chaos.</strong> Different teams at Airtasker instrument their services differently. Some use OpenTelemetry, some use native Datadog APM, some have custom metrics with naming conventions that only make sense if you were there when they were created. We didn’t want users to need to know that one service uses trace.web.request while another uses otel.http.server.duration.p99. That&#39;s ridiculous.</p><p>Solution: try multiple metric patterns in parallel, see what returns data, and cache what works. First query for a new service might take a moment while it figures things out. After that, it remembers. Not elegant, but it works.</p><p><strong>Knowing when to say “I don’t know.”</strong> Early versions would confidently present correlational evidence as if it were proof. “The deploy happened right before errors started” is interesting, but it doesn’t mean the deploy caused the errors. During an incident, confident wrong answers send people down the wrong path. That’s worse than no answer.</p><p>We built a two-layer confidence system. First layer is objective: did the API calls work? How much data came back? How fresh is it? The second layer is about reasoning quality. The agent tags its own evidence as direct (“logs show a 500 error at 3:14pm”), correlational (“deploy happened right before errors”), or speculative (“might be related to the config change”).</p><p>The key bit: correlational evidence caps confidence at 65% regardless of how much data supports it. The bot shows its confidence and explains why. Helps people know when to dig deeper.</p><p><strong>Confirmation bias.</strong> If you ask a leading question like “Is the outage caused by the Redis failover?” the bot would find ways to support that theory even when the evidence was thin. We added explicit self-assessment: the agent has to consider alternative explanations and whether the evidence actually supports the conclusion or just doesn’t contradict it.</p><p>Still not perfect. But better.</p><h3>The Bit That Just Runs in the Background</h3><p>The bot polls Datadog for new incidents every few seconds. When one fires, it finds the Slack channel, joins it, and posts an initial context dump before anyone’s even looked at it.</p><h3>What We’ve Learned</h3><p>I want to be careful not to oversell this. The bot gathers context. It doesn’t solve incidents. The hard work of diagnosing root cause and fixing things still falls on humans, and that’s how it should be.</p><p>But context gathering is genuinely time-consuming, and automating it will greatly help save time. Senior engineers save time. Junior engineers get a way to participate. Everyone benefits from a shared baseline of information in the channel from the start.</p><p>The multi-agent architecture arose from cost pressures and a fit-for-purpose need, not from grand design. The confidence scoring came from watching the bot mislead a few times. Most of what works well emerged from iterating on what didn’t.</p><p>We’re calling it Clanker, which is a silly name, but it stuck.</p><p>Still lots to improve. Better deploy-to-error correlation. Automatic runbook suggestions. Feedback on the quality of responses and more, but the core loop is solid.</p><p>If you’re thinking about building something similar: start simpler than you think, instrument everything so you can see what’s actually happening, and don’t trust your LLM to know when it doesn’t know something. That last one will bite you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ada06e9294e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/we-built-a-bot-that-does-the-first-10-minutes-of-every-incident-for-you-5ada06e9294e">We Built a Bot That Does the First 10 Minutes of Every Incident For You</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RubyLLM and the Return of Rails’ Superpower — Notes from Euruko 2025]]></title>
            <link>https://medium.com/airtribe/rubyllm-and-the-return-of-rails-superpower-notes-from-euruko-2025-b72eeeb6b185?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/b72eeeb6b185</guid>
            <category><![CDATA[euroku]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <dc:creator><![CDATA[Niko Roberts]]></dc:creator>
            <pubDate>Fri, 05 Dec 2025 15:50:23 GMT</pubDate>
            <atom:updated>2025-12-05T15:50:22.546Z</atom:updated>
            <content:encoded><![CDATA[<h3>RubyLLM and the Return of Rails’ Superpower — Notes from Euruko 2025</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*py_epAvxem8TZKdlMJSzwQ.png" /></figure><p>In September, the Airtasker Portugal team travelled to Viana do Castelo for Euruko 2025, a stunning coastal setting, great food, and a conference full of reminders of why the Ruby community still feels different from any other ecosystem.</p><p>But one talk towered above the rest for us:<br><strong>Carmine Paolino’s “Python Owned Training. Ruby Owns Building.”</strong></p><p>What Carmine articulated so clearly and what resonated deeply with our entire team is that the core superpower of Ruby and Rails has always been the ability to build<strong> quickly</strong>.</p><h3>Rails is about turning ideas into products… fast.</h3><p>Not ML training.<br>Not fine-tuning.<br>Not complex orchestration layers.</p><p><strong>Building.</strong></p><p>And RubyLLM is the first framework that treats AI the way Rails treats web development:<br>Opinionated. Productive. Fast.</p><p>Below is why this talk resonated with us and why it left our team energised about the future of Rails, including its role in how Airtasker builds AI-powered features.</p><h3>Rails Has Always Been the Framework for Builders</h3><p>Carmine opened with a reminder that many of us needed to hear:</p><blockquote>“Ruby doesn’t need to compete with Python in training. Our DNA is building products.”</blockquote><p>Since 2005, Rails’ magic has been:</p><ul><li>conventions that remove decisions</li><li>generators that scaffold working apps instantly</li><li>helpers and DSLs that compress huge amounts of work</li><li>a community focused on product delivery, not tech theatre</li></ul><p>Rails is what let small teams build Twitter, Shopify, GitHub, Basecamp, Airbnb, not because Ruby was the fastest language, but because <strong>Rails let small teams out-ship large teams</strong>.</p><p>Carmine’s argument:<br><strong>AI development is collapsing back into Rails’ home turf.</strong></p><p>Not research.<br>Not training workloads.<br><strong>Product development.</strong></p><h3>AI Has Shifted From “Research” to “Building”</h3><p>Carmine highlighted how the AI landscape has fundamentally changed.</p><p>A few years ago, AI work meant:</p><ul><li>GPUs</li><li>model training</li><li>data pipelines</li><li>giant notebooks</li><li>days of experimentation</li></ul><p>Now, for 99% of AI apps, it’s:</p><ul><li>calling APIs</li><li>managing prompts</li><li>building interfaces</li><li>routing workflows</li><li>combining tools</li><li>delivering user value</li></ul><p>That’s <strong>just product development</strong>. Which is exactly where Ruby and Rails thrive.</p><p>So the question becomes:</p><h3>If AI is now about building products… why are we using Python?</h3><p>Carmine’s answer:<br><strong>We shouldn’t be.</strong></p><h3>RubyLLM Is Rails for AI Apps</h3><p>This was the heart of the talk.</p><p>RubyLLM takes the best of Rails’ philosophy, convention, productivity, clarity, and applies it directly to AI development.</p><h3>1. One API to Rule Them All</h3><p>chat.ask works across 620+ models.<br>Switching from GPT-4 to Claude to Gemini is just changing a string.</p><p>Rails-like simplicity.</p><h3>2. Generators for Instant Prototypes</h3><p>Want a fully working chat UI?</p><pre>rails g ruby_llm:install<br>rails g ruby_llm:chat_ui</pre><p>Done.</p><p>Database tables, streaming UI, cost tracking, all wired up.</p><h3>3. No More “Complexity Theatre”</h3><p>While other ecosystems load six libraries and three config objects just to generate a sentence, RubyLLM leans into Ruby’s expressiveness:</p><ul><li>Templates are Ruby strings</li><li>Tools are Ruby methods</li><li>Schemas are Ruby hashes</li></ul><p>“Simple should be simple, and complex should be possible.”</p><h3>4. Scaling on One Machine</h3><p>Fibers + Async let you run thousands of concurrent AI calls without worker exhaustion.</p><p>Rails developers get supercomputing-style concurrency, with no added mental overhead.</p><h3>This Is Rails’ Territory — Velocity, Craft, and Focus</h3><p>Carmine brought us back to the thing Rails does better than almost any other framework in history:</p><h3>Rails lets small teams build ambitious things quickly, and RubyLLM does the same for AI.</h3><p>This message landed strongly with our team because it mirrors what Airtasker needs:</p><ul><li>fast iteration</li><li>rapid prototyping</li><li>tight feedback loops</li><li>high leverage per engineer</li><li>the ability to build real features, not abstractions</li></ul><p>AI is no longer a research problem.<br>It’s a <strong>product</strong> problem.</p><p>And Ruby is the product-builder’s language.</p><h3>Why the Airtasker Portugal Team Left Energised</h3><p>We walked out of Carmine’s talk genuinely fired up, because it reaffirmed that:</p><ol><li><strong>Rails still has its superpower, shipping fast.</strong></li><li><strong>RubyLLM amplifies that superpower for AI.</strong></li><li><strong>The Rails community is swinging back towards its roots: enabling builders.</strong></li><li><strong>Small teams, like ours, can punch far above their weight in the AI era.</strong></li></ol><p>For years, the narrative has been that Rails is “stable but quiet.”</p><p>Euruko 2025 proved the opposite.<br>Rails is evolving, adapting, and <em>hungry</em> again.</p><p>RubyLLM is the clearest sign that the community is ready for its next renaissance, one where Rails isn’t just relevant, but essential, for building AI-powered products.</p><h3>Final Reflection</h3><p>The biggest insight Carmine delivered was not about models, providers, or concurrency tricks. It was this:</p><blockquote><strong><em>Rails is, and always has been, the fastest way to turn ideas into software.</em></strong><em><br></em><strong><em>RubyLLM makes that true for AI, too.</em></strong></blockquote><p>That’s why this talk hit so hard.<br>That’s why our team left Viana buzzing.<br>And that’s why the future of Rails, and the future of building AI at Airtasker, looks brighter than ever.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b72eeeb6b185" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/rubyllm-and-the-return-of-rails-superpower-notes-from-euruko-2025-b72eeeb6b185">RubyLLM and the Return of Rails’ Superpower — Notes from Euruko 2025</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Upgrading Airtasker from Rails 4.2 to Rails 5.x]]></title>
            <link>https://medium.com/airtribe/watch-your-language-f6ad1e0f1abf?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/f6ad1e0f1abf</guid>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[upgrade]]></category>
            <dc:creator><![CDATA[Niko Roberts]]></dc:creator>
            <pubDate>Fri, 05 Dec 2025 15:42:59 GMT</pubDate>
            <atom:updated>2025-12-05T15:55:39.187Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Originally posted in 2019. Republished in Dec 2025 as we are going through the upgrade process from Rails 7 to 8 and will be writing the next chapter on Rails upgrades soon.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kQ_tGAkONG4lm4giGCjFlQ.png" /></figure><p>Why would we take on this? Security patches, dependency support, speed. For example, small optimisations that improve JSON serialisation by the Rails team can mean hundreds or thousands of requests per second more being able to be served on a system at scale like Airtasker.</p><p>The first commit in preparation for upgrading the Airtasker monolith from Rails 4 to Rails 5 happened in 2016 by one of the engineers that is now long gone.</p><p>Over the 3 years since that commit, the road was very slow with the occasional bursts of enthusiasm but day-to-day there was very little time to spend on developing a strategy to roll it out.</p><p>In 2018 when I joined the company the lack of confidence in our automated test suite, the slowness of our deploys and rollbacks, and large chunks of our incompatible tech debt all were nails keeping the door well and truly sealed for us.</p><p>In September 2018, the inspiring <a href="https://medium.com/u/179816037ba8">Eileen M. Uchitelle</a> wrote a post on Github’s blog post on how she guided <a href="https://github.blog/2018-09-28-upgrading-github-from-rails-3-2-to-5-2/">Github’s upgrade of their monolith</a> from 3.2 to 5.2 (and now 6). This became the basis of the strategy many companies utilised to go through this transition, including ours at Airtasker.</p><h4>Fierce Creatures 19.1</h4><p>Our CEO <a href="https://medium.com/u/dc55aa2b6242">Tim Fung</a> has managed to hire a great team of senior engineering leaders that have advised him very well. Every 6 months we have a 2 week sprint where ALL engineers pause their product team work and work on large projects to remove tech debt, crush bugs or refactor some of the hairiest code. This sprint is called “Fierce Creatures”.</p><p>At the beginning of 2019 we still had some significant blocking tech debt and our deploys were slow and painful (using AWS CodeDeploy). But we had light at the end of the tunnel and thanks to Eileen, we had a pretty good idea about what we needed to work on for the first Fierce Creatures so we could actually clear the way for the upgrade.</p><p>In late Feb 2019 we removed the largest, hairiest piece of tech debt we had, we finishing cleaning up a lot of the big deprecations and we moved our deployments from CodeDeploy and EC2 into Kubernetes. We ended up reducing our deploy time from about 30–40m to 2–5m.</p><h4>Preparing for Fierce Creatures</h4><p>As a Tech Lead at Airtasker I took it upon myself to lead the charge on the Rails 5.0 upgrade in September. I had worked on similar upgrades of smaller projects previously and remembered some of the caveats and areas we needed to watch for.</p><p>I also knew that we needed to have a well orchestrated and conservative approach that would get us across the line safely and if we didn’t we could cause a major disruption or the effort could easily bleed into regular work time.</p><p>Myself and one of my team Chris figured out the actual build and test strategy within our continuous integration platform (Circle CI). We added a second build step that ran all the tests using a separate Rails 5.0 Gemfile in parallel with our production Rails 4.2 Gemfile.</p><p>After we got those initial failing builds, our goal was to make the list of test failures as representative of actual work needed as possible. So during Fierce Creatures we could divide up the work as accurately as possible.</p><p>We exemplified conditional methods for different versions of Rails and we fixed the major configuration failures that were not Rails 5.0 compatible. In the end we had ~260 tests failing out of 5500.</p><h4>Fierce Creatures 19.2</h4><p>The week before the sprint, the plan was a 3 main streams of work:<br>1. Divide up and fix the 260 failing tests<br>2. Create a safe parallel deployment strategy<br>3. Get as many of our client e2e test suites easy to use on our parallel deployments</p><p>The goals were conservative:<br>1. Upgrade from Rails 4.2 to Rails 5.0 in production<br>2. Have a repeatable, safe and reliable process for future upgrades</p><p>By Wednesday of the first week Rails 5.0 had a green build and we had deployed into our staging environments and were running our client e2e test suites against it.</p><p>Our deployment strategy was similar to how we had made the transition to Kubernetes earlier in the year. By using a Cloudflare Load Balancer to cut over traffic from one deployment to another.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6ad1e0f1abf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/watch-your-language-f6ad1e0f1abf">Upgrading Airtasker from Rails 4.2 to Rails 5.x</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rolling out Claude Code at Airtasker]]></title>
            <link>https://medium.com/airtribe/rolling-out-claude-code-at-airtasker-72990b901998?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/72990b901998</guid>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Asher Moore]]></dc:creator>
            <pubDate>Mon, 10 Nov 2025 01:33:59 GMT</pubDate>
            <atom:updated>2025-11-10T01:33:56.064Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post is part of a series exploring how Airtasker rolled out Claude Code across engineering, from kick-starting adoption and managing change, to building the systems that make it scale. In this instalment, we look at how the SRE team brought Claude to life and made it observable across the organisation.</em></p><p>At Airtasker, we’d been quietly experimenting with large language models for a while. The promise was appealing: faster iteration, fewer repetitive tasks, and a smoother path from idea to implementation.</p><p>We started with GitHub Copilot. It was fine, helpful at times, but it often felt like a black box. The code suggestions didn’t always match our patterns, and it rarely felt worth reshaping our workflows around. Eventually, we realised it wasn’t giving us what we needed: clarity, adaptability, and confidence.</p><p>So we kept looking.</p><p>When Claude Code appeared, it immediately felt different. It worked from the terminal, which made it a natural fit for our environment. Engineers could use it across any editor or setup without plugins or lock-in. It was just a lightweight command-line tool that stayed out of the way and helped write clean, readable code.</p><p>Before rolling it out, we had to decide: should we use Claude Code directly through Anthropic, or run it via AWS Bedrock? We spoke with both teams and chose Bedrock. The deciding factor was data sovereignty. Running Claude within our own AWS account gave us control over data storage and processing while still allowing access to Anthropic’s models.</p><p>It also introduced a new consideration: cost visibility. Anthropic offers both pay-per-use access and flat-rate options like the Claude Max subscription, but using Bedrock’s usage-based model helped us validate our suspicion that Claude Code was the right fit for our engineers. It gave us the flexibility to scale naturally with real usage while maintaining data sovereignty, a combination that made the overall approach a much better fit for Airtasker.</p><p>From there, the rollout became as much about observability as it was about adoption.</p><h3>Making it Work Everywhere</h3><p>We’re a Mac shop and manage devices through Kandji, so we started by integrating Claude into that ecosystem. A simple shell script deployed to each engineer’s laptop pulled metadata like serial number, username, and email from managed preferences. It then wrote a small managed-settings.json file to /Library/Application Support/ClaudeCode/.</p><p>That file quietly set up Claude’s environment, enabling OpenTelemetry, tagging sessions with device and user data, our global context documents and sending lightweight telemetry. It wasn’t intrusive, but it gave us enough to understand usage patterns across the team.</p><p>Next, we extended our Ansible playbook to handle installation and updates automatically. Each engineer’s setup ensured Claude Code was in the PATH and correctly configured with environment variables for AWS Bedrock. This allowed engineers to choose between models like Opus, Sonnet or Haiku without needing to worry about authentication or quotas. Claude just worked when they needed it to.</p><p>We didn’t want anyone thinking about setup or configuration. The goal was for Claude to feel like part of the operating environment, present, reliable, and invisible.</p><h3>Seeing How It Was Used</h3><p>Once it was running, we wanted to understand how it fit into real workflows. Not to monitor individuals or track who was and wasn’t using Claude, but to learn. The dashboard helped surface patterns we hadn’t anticipated, like identifying engineers who hadn’t yet gotten the hang of using separate chats for different tasks. By comparing tokens to sessions, we could spot when usage patterns suggested confusion rather than productivity. This early visibility proved invaluable in the first few weeks, helping us guide adoption and fine-tune how Claude was introduced across the team.</p><p>We deployed an OTEL Collector to receive telemetry from Claude and export it into Datadog. From there, we could track metrics such as:</p><ul><li>Token usage (input, output, total)</li><li>Active users and devices</li><li>Programming languages</li><li>Session length and frequency</li><li>Suggestions accepted vs ignored</li><li>Pull requests raised after sessions</li></ul><p>These metrics gave us a living view of how Claude was being used, not just whether it was installed. We also enriched the data with GitHub metadata so we could correlate usage with repositories and contributors. Over time, we hope this helps us better understand patterns of developer productivity across different teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tcnyvkMaomdajI5cdbT-aA.png" /></figure><h3>Understanding the Cost</h3><p>One of the early surprises was how difficult it was to see accurate costs. Claude’s CLI reports pricing based on Anthropic’s direct rates, but our usage ran through AWS Bedrock. The numbers didn’t align. Different models, rates, and billing structures meant we couldn’t rely on the default output.</p><p>So we built our own tracker.</p><p>We captured Bedrock invocation logs via CloudWatch, processed them through a Lambda function, and pushed custom metrics into Datadog. Each metric carried tags for model type, caller, user, and environment. This gave us real visibility into spend, broken down by team and purpose.</p><p>Now we can see, for instance, when a team leans too heavily on an expensive model like Opus for tasks that Haiku could handle just as well. We can forecast budgets, set alerts, and make informed trade-offs before costs become a surprise.</p><p>It’s not perfect, but it’s far better than trusting what the CLI tells you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0oIbQ-DDwvZhHPB528w7aQ.png" /></figure><h3>What We Learned</h3><p>Rolling out Claude Code wasn’t really about AI. It was about integrating something new into an existing culture without disrupting it.</p><p>We didn’t want to automate creativity or replace engineering judgment. We wanted to remove friction, to help people get into flow a little faster and spend more time solving interesting problems.</p><p>The rollout succeeded not because of the technology itself, but because of how quietly it blended in. By focusing on invisible setup, meaningful telemetry, and clear cost visibility, we built trust in the tool and in our approach to AI adoption.</p><p>AI in engineering isn’t about disruption. It’s about integration. The best tools don’t try to be the centre of attention. They just make good work a little easier.</p><p>Claude Code did exactly that.</p><p>This project was only possible because of our incredible SRE team. They took an idea that could have been just another AI experiment and turned it into something reliable, measurable, and genuinely useful for engineers across Airtasker. Watching them bring it to life with such care and craftsmanship has been one of the most rewarding parts of the journey, and I couldn’t be prouder of what they’ve built.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72990b901998" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/rolling-out-claude-code-at-airtasker-72990b901998">Rolling out Claude Code at Airtasker</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[hello world, again!]]></title>
            <link>https://medium.com/airtribe/hello-world-again-1032b47dfe65?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/1032b47dfe65</guid>
            <dc:creator><![CDATA[Chaitanya Kuber]]></dc:creator>
            <pubDate>Mon, 10 Nov 2025 01:13:46 GMT</pubDate>
            <atom:updated>2025-11-10T01:13:44.913Z</atom:updated>
            <content:encoded><![CDATA[<p>It’s been a while. Too long, actually.</p><p>When I look back at the last posts on this blog from 2020, I see a vibrant community eager to share knowledge, tackle hard problems, and push the boundaries of what’s possible. That spirit has never left Airtasker: it just needed a new home to breathe.</p><p>I’m thrilled to reawaken this publication and introduce myself as Airtasker’s CTO. My mission is simple: foster a culture where world-class talent thrives, where technology accelerates our business, and where we solve problems that matter for millions of people who use our platform every day.</p><h3>The AI Acceleration Era</h3><p>We’re at an inflection point in software engineering. AI isn’t just changing what we build — it’s fundamentally transforming how we build it.</p><p>At Airtasker, we’re leaning into this transformation. We’re deploying AI across our engineering organisation to accelerate everything from writing code to code reviews and architecture decisions, from debugging to deployment strategies. Our engineers are shipping faster, thinking bigger, and solving harder problems than ever before.</p><p>Here’s what excites me most: we’re not using AI just as a productivity tool. We’re using it to elevate our entire practices, amplify our impact while making space for deeper thinking, better design, and more ambitious innovation.</p><h3>What You’ll Read Here</h3><p>We have stories to tell. Over the coming months, you’ll hear from our engineering teams about:</p><ul><li>Our engineering culture and what makes Airtasker special</li><li>AI-powered development and how we’re integrating it into our daily workflows</li><li>Our platform engineering efforts where we build infrastructure for millions of users</li><li>Architecture decisions and trade-offs from evolving a complex marketplace</li><li>How we leverage data and machine learning for better experiences</li><li>Mobile engineering across iOS and Android</li><li>The developer experience that helps our engineers do their best work</li></ul><h3>Why Now?</h3><p>The world has changed dramatically since our last post. Remote work, AI breakthroughs, new architectures, evolving user expectations: engineering in 2025 looks nothing like it did in 2020.</p><p>At Airtasker, we’re navigating this landscape with intention. We’re building products that help people get things done, and we’re building an engineering organisation that can adapt, innovate, and excel in this new era.</p><p>This blog is our way of sharing that journey: the wins, the challenges, the experiments, and the lessons learnt. We believe in learning in public and contributing back to the broader engineering community.</p><h3>Join the Conversation</h3><p>Whether you’re an engineer considering your next move, a technical leader navigating similar challenges, or someone curious about how modern engineering teams operate, we want this to be a valuable resource for you.</p><p>We’re just getting started. There’s so much to share, and I can’t wait to introduce you to the brilliant engineers building the future of Airtasker.</p><p>Welcome back!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1032b47dfe65" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/hello-world-again-1032b47dfe65">hello world, again!</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blood, Bones, and Muscle]]></title>
            <link>https://medium.com/airtribe/blood-bones-and-muscle-35ed3486fd07?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/35ed3486fd07</guid>
            <category><![CDATA[coo]]></category>
            <category><![CDATA[culture-change]]></category>
            <category><![CDATA[people-operations]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[process-improvement]]></category>
            <dc:creator><![CDATA[Yaniv Bernstein]]></dc:creator>
            <pubDate>Wed, 28 Oct 2020 20:52:43 GMT</pubDate>
            <atom:updated>2020-10-28T20:52:43.422Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Hi, I’m Yaniv, Airtasker’s COO. For the past few months I have been writing a newsletter discussing topics of organisational performance and other COO-related themes. I have reproduced one of my recent articles below. If you find it interesting, please head over to </em><a href="http://wtfisacoo.substack.com/"><em>http://wtfisacoo.substack.com</em></a><em> to subscribe (it’s free!) and access more content.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*onQXdJLq3I9KaDegV-JuGQ.png" /></figure><p>I’ll start with a story.</p><p>The first ten years of my career were spent at Google. While not all the legends are true, it is undoubtedly the case that the quality of software engineering at Google was very high. Software had to be well designed, and every changelist (~=Pull Request) had to be thoroughly and rigorously reviewed before being merged.</p><p>Most Google Software Engineers remember their first code review. The barrage of feedback, the many iterations, and finally the congratulations of team mates when it finally got that “LGTM” (Looks Good To Me). It was nerve-wracking, but the message was clear: your code had to be good before it made it into the repository.</p><p>When I left the Google nest to join my first startup as VP Engineering, I was rather shocked to find out that my team of engineers didn’t do code reviews at all. Instead, people merged straight to master and from there to production. Madness! Using my new executive boss power and a deep sense of righteousness, I mandated a pull request process within my first week.</p><p>Job done.</p><p>Except it wasn’t. I monitored the reviews, and nobody was giving anybody any feedback. Reviews were being treated as rubber stamps, just useless bureaucracy. Frustrated, I gathered the team and impressed on them the importance of thoroughly reviewing each other’s work for the sake of the codebase.</p><p>Everything seemed to be going OK until a couple of weeks later, when one of my engineers (let’s call him Rio) furiously pulled me into a meeting room.</p><p>“You have to do something about Igor. He’s being such an arsehole!” he exclaimed.</p><p>“Why? What’s he been doing?”</p><p>“He’s blocking my code!”</p><p>“What do you mean by blocking?”</p><p>“He’s saying all this shit on the pull requests and stopping me from merging. It’s disrespectful.”</p><p>It turns out that Igor was doing exactly what I’d asked all the engineers to do: review code rigorously and uphold the quality of our codebase. I knew I’d failed completely when Igor came to me the following week to let me know he was going back to rubber stamping PRs in order to avoid offending his colleagues.</p><h3>Process is bones, culture is muscle</h3><p>I learned a valuable and brutal lesson from all this. A process without the cultural alignment to bring it to life is like a skeleton, inert and useless.</p><p>Similarly, I have heard from those who have worked at organisations where there was a strong culture of quality software but a lack of defined process. As the organisation scaled the lack of process meant that the culture started to become a liability, devolving into a maze of cliques and undocumented expectations.</p><p>Bones need muscle, muscle needs bones. The two together constitute an interdependent working system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*WTC0TQdzGIPuQ2q_.jpeg" /></figure><p>When I joined my next organisation, the lesson of the failed pull requests was seared into my mind. Things were in quite a bit better shape there, with code review already in place and some amount of discussion, but nowhere near the level of fearless rigour I had been used to at Google. The bones were there, and there was a muscle but it was a bit weak and underdeveloped. I saw that it was my job job to strengthen it.</p><p>I published a <a href="https://medium.com/airtribe/why-code-reviews-matter-54fb69f8d9cc">manifesto</a> where I clearly spelled out the cultural expectations. I recruited allies inside the organisation. I repeated myself a lot. I repeated myself a lot. I had a lot of one-to-one conversations. And I watched. Slowly, over time, things got better. Time and reps built up the muscle.</p><p>Another thing to note: as any serious gym-goer will tell you, working on one muscle and neglecting others is a sure way to cause injury. I saw that a key part of my work on better pull requests was to build up the bones and muscle around architectural design as well. When creating processes and cultural expectations, consider where else stress points will emerge and work at the same time to strengthen your organisation there.</p><h3>A circulatory system for information</h3><p>A couple of years back we got a review on Glassdoor slamming us for a lack of transparency. Then, a few weeks later, another one. How could that be? As a management team we strived to be transparent. We shared our numbers with the team, discussed strategy, updated them on our capital raising efforts. There were few secrets. And yet: “management preaches transparency but does not practice it”.</p><p>Even more recently, frustration grew the other way. Upper management felt that we had no effective way of finding out what was going on in the teams that we responsible for. Any attempt to extract that information inevitably felt heavy-handed and unwelcome. What was going on?</p><p>On reflection, transparency is completely the wrong term for what people in an organisation really want and need. Information is not some inert substance that simply is put on display for viewing. Instead, it needs to get to people at a time and in a form that enables them to do their jobs. It needs to go down, up, and across. Simply but: in order for the the organisation to remain effective, information needs to <em>circulate</em>.</p><p>Circulation of context and information is way more than mere transparency. Many questions need to be answered: Who needs to know what information? At what times? What form should it be in to be digestible? How does information get updated and refreshed? And so on.</p><p>Indeed, the circulatory system itself requires significant process design, and significant cultural investment to get right.</p><p>It’s worth it though: without adequate circulation of information the many muscles in your organisation’s body will begin to wither and die.</p><h3>Keep your organisation healthy</h3><p>Every metaphor has its breaking point, and this one is no different. There are many ways in which organisations are not like the human body! But I have found these three parts — blood, bones, and muscle — to be foundational to a healthy, well-functioning team. Tend to all three, and it’s amazing how many other things will work themselves out.</p><p><em>Still here? Please consider heading over to </em><a href="http://wtfisacoo.substack.com/"><em>http://wtfisacoo.substack.com</em></a><em> to get access to more of my writings.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35ed3486fd07" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/blood-bones-and-muscle-35ed3486fd07">Blood, Bones, and Muscle</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enforcing Modularity inside a Rails Monolith]]></title>
            <link>https://medium.com/airtribe/enforcing-modularity-inside-a-rails-monolith-f856adb54e1d?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/f856adb54e1d</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[rails]]></category>
            <dc:creator><![CDATA[Thomas Pagram]]></dc:creator>
            <pubDate>Tue, 11 Aug 2020 05:36:35 GMT</pubDate>
            <atom:updated>2020-08-11T05:36:34.984Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UJw8YosL0TUs5BAw" /><figcaption>Photo by <a href="https://unsplash.com/@hulkiokantabak?utm_source=medium&amp;utm_medium=referral">Hulki Okan Tabak</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Like many startups of its age, Airtasker was born as a Ruby on Rails monolith which got a bit bloated.</p><p>We believe a modern API architecture consists of a set of loosely-coupled, highly-cohesive <em>bounded contexts</em>. A bounded context is a term from Domain-Driven Design (DDD) which refers to the logical boundaries surrounding a single subdomain of a business.</p><p>At Airtasker, greenfield bounded contexts usually come in the form of a Kotlin microservice. But what about the core functionality we already have? When you do the cost-benefits analysis of rewriting a large chunk of code that already exists and works, it’s easy to conclude that you <a href="https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/">shouldn’t rewrite</a>.</p><p>Fortunately, a bounded context doesn’t necessarily imply a separate service. In fact, there are lots of benefits to having a <a href="https://engineering.shopify.com/blogs/engineering/deconstructing-monolith-designing-software-maximizes-developer-productivity">modular monolith</a>. Like many before us, we’ve made use of <a href="https://guides.rubyonrails.org/engines.html">Rails engines</a> for modularity within our Rails app.</p><p>Unfortunately, adding and enforcing boundaries between Rails Engines is a DIY job. In this blog, I’ll walk you through:</p><p><strong>1. Where we started</strong>. The status quo of our Rails Monolith and our use of engines and adaptors.</p><p><strong>2. Why we want to enforce boundaries. </strong>Our motivation for trying to enforce strict and explicit boundaries between our Rails Engines.</p><p><strong>3. How we enforced boundaries. </strong>A walk-through of the methods we tried and the benefits and downsides of each.</p><h3><strong>1. Where we started</strong></h3><h4>Bounded Contexts</h4><p>Our monolith is partially, but not yet entirely, carved up into a set of bounded contexts.</p><p>As we mentioned in the intro, a bounded context is a term borrowed from DDD that refers to a single business subdomain with well-defined boundaries. Since this can be difficult to conceptualise, let’s walk through an example.</p><p>Imagine you’re an engineer at the hotshot cat grooming startup Luxuricat<em> </em>that just made it through Series C funding. Your business and codebase have grown so large that it’s no longer feasible to have a unified domain model. Each product team seems to have their own concerns and vocabulary for their respective parts of the app. Yet they’re also constantly treading on each other’s toes.</p><p>Since you want to keep up momentum, you decide to try and modularise your codebase along the lines of the different subdomains of your business. To identify those subdomains, you chat with domain subject-matter experts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y-NEYNiX_z7V_nSXzHLDTg.png" /><figcaption>Possible business subdomains for Luxuricat</figcaption></figure><p>You find a few obvious subdomains<em> </em>that aren’t special to Luxuricat,<em> </em>like <em>Notifications</em> and <em>Payments</em>. These <em>Generic Subdomains </em>are prime candidates to be extracted. You’re also surprised to find out that the needs of your pampered cats have little to do with the rostering of cat groomers. This seems like two different <em>Core Subdomains </em>of your business, so you decide to create two more bounded contexts: <em>CatClients and CatGroomers.</em></p><p>Each of these bounded contexts has their own domain model and can be owned entirely by a single product team. As long as these contexts have well-defined boundaries, each team can work autonomously within their own business subdomains without fear of disruption to others.</p><p><strong>Rails engines</strong></p><p>In our monolith we’ve used <a href="https://guides.rubyonrails.org/engines.html">Rails Engines</a> to encapsulate our bounded contexts. According to the docs, Rails Engines are ‘miniature applications that provide functionality to their host applications’. While they do come with a bunch of useful tools out-of-the-box, the modularity they provide is mostly superficial. We’ll explore why soon.</p><p>Given this modularity is paper-thin, you may ponder their value. Why not just properly rip out functionality into a service? There’s no boundary harder than an HTTP call.</p><p>Other than being a much smaller commitment, there is one massive benefit.</p><p>Our engines are essentially nurseries for baby services. According to DDD, your domain model is constantly evolving and you’re going to get a lot wrong. The worst case scenario is you get it wrong enough to end up with a distributed monolith, which is miles worse than the monolith you started with.</p><p>Getting the boundaries wrong between services means weeks of refactoring. Getting the boundaries wrong between engines means spending 15 minutes moving some code around before your next meeting.</p><h4>What do our boundaries look like?</h4><p>For our Kotlin microservices, we jumped fully onboard the Hexagonal hype train.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jPQoIVf6KmoaUjpmVy_96A.png" /><figcaption>Driving and Driven Adaptors in Hexagonal Architecture</figcaption></figure><p>I don’t want to delve too deep into Hexagonal Architecture, but here’s the 5-second summary: protect your domain logic with adaptors.</p><p>Given ActiveRecord and the lack of interfaces, most of Hexagonal doesn’t translate well into the Rails world. You’ll be fighting uphill if you want to truly adopt it. However, one fundamental part does translate perfectly — protect the core domain logic with adaptors.</p><p>Hexagonal splits the adaptors into two kinds: <em>inbound</em> <em>(driving) </em>adaptors<em> </em>and <em>outbound (driven)</em> adaptors.</p><p>Inbound adaptors are entry points to an application that drive a particular user flow (for example, a Rails controller).<em> </em>Outbound adaptors are external calls that the application initiates — think the DB, payment providers, email, etc.</p><p>At its finest, Hexagonal promises to let you switch technologies without touching a single line of business logic. Want to move between REST, gRPC or CLI input? No worries, just write some more adaptors.</p><h4>How does that apply to Rails engines?</h4><p>Since we’ve established our engines are baby services, there’s no reason they shouldn’t attempt to follow the same pattern. Each of our engines defines a set of inbound and outbound adaptors specifically for inter-engine communication.</p><p>Let’s return to our cat grooming startup Luxuricat. If the <em>CatGroomers </em>engine<em> </em>needs to grab information about a cat in the <em>CatClients </em>engine, it doesn’t stick its hand over the fence and call:</p><pre>cat = CatClients::Cat.find(cat_id)</pre><p>This would put us straight on the highway to Coupling Town. Instead, we can go through an outbound adaptor:</p><pre><em>deserialised_cat_model = CatGroomers::OutboundAdaptors::CatClients.fetch_cat(cat_id)</em></pre><p>Which at some point would call an inbound adaptor in the <em>CatClients</em> engine:</p><pre><em>serialised_cat_model = CatClients::InboundAdaptors::Cat.fetch(id)</em></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6uizi6dloxROMKVZ" /></figure><p>The call between the outbound and inbound adaptor is the engine boundary. Since this essentially forms the interface of the <em>CatClients</em> engine, it’s worthwhile making that interface explicit. We often use <a href="https://dry-rb.org/gems/dry-validation">dry-validation</a> for this purpose.</p><p>At first glance this may seem like a lot of extra boilerplate. However, since these adaptors use the medium of method calls rather than HTTP, their contents are generally super slim. Serialisation is barely more than putting attributes of a domain model into a hash, and you don’t need to bang your head on the wall with retries or handling response codes.</p><p>Adding these adaptors has additional value:</p><p>1. It encourages interface-first development.</p><p>2. It makes inter-engine communication explicit and observable.</p><p>3. If we do need to pull out an engine into a service, no domain logic needs to change.</p><h4>So what’s the issue?</h4><p>Great, so we can add a bunch of these adaptors and only communicate through them to other domains. Problem solved, right?</p><p>Unfortunately not.</p><p>Rails has something it calls an ‘autoloader’. In Rails 6 this is handled by the gem <a href="https://github.com/fxn/zeitwerk">Zeitwerk</a>, which according to the README means you ‘<em>don’t need to write require calls for your own files, rather, you can streamline your programming knowing that your classes and modules are available everywhere</em>’.</p><p>In your Rails app, pretty much every class is available everywhere. Yet in our case, we’re deliberately trying to protect our domain logic so it isn’t available outside of its bounded context.</p><h3><strong>2. Why we want to enforce boundaries</strong></h3><p>What we’ve described is the state of Airtasker’s monolith. We’ve got subdomains inside engines using inbound and outbound adaptors, relying on culture and code review to encourage their use.</p><p>So why experiment with enforcing boundaries? There are two motivations.</p><h4>2.1 — Make it hard to do the wrong thing</h4><p>The first benefit is the obvious one that comes to mind: encouraging good behaviour.</p><p>When a developer writes code in a domain and realises they need information from an entity in another domain, ideally they’d pause and go back to the domain model and ask themselves questions.</p><p>1. Is this model in the right domain?</p><p>2. If it is, should I add adaptors between these two domains?</p><p>3. What should the contract look like?</p><p>Whatever the outcome of their domain puzzling session is, 90% of the time it’s going to be more effort than simply reaching out and grabbing the model directly. And if a developer is new to the codebase, they may not even be aware of the adaptor pattern at all.</p><p>‘But wait!’ you cry out. The developers that work on your application are super switched-on and go through a rigorous code review process. They’d never let human error like that get through.</p><p>That is fair — we can presume most instances of boundary leakage would never make it through PR. However, not all boundary leakage issues will be so obvious as <em>leaky_model = AnotherDomain::LeakyModel. </em>In our decoupling efforts, we discovered some real head-scratchers.</p><p>Cultural practises can only take you so far. When the path of least resistance is at cross-purposes with your architecture, time and entropy will slowly erode code quality.</p><h4>2.2 — Measure progress</h4><p>If it’s worth doing, it’s worth measuring.</p><p>If you start with a bloated monolith and want to take proactive steps towards decoupling it, you need to invest significant time, effort and creativity. Progress will be slow and improvements won’t be obvious. At first, developer productivity on the monolith may even start to decline. You may have to deal with sceptics.</p><p>Adding a bunch of adaptors and reducing coupling is a vague goal. Humans hate vague goals. It makes us anxious and unmotivated.</p><p>On the flip side, humans love seeing numbers go up or down. We love discrete blocks of work that can be said to be <em>done.</em></p><p>For us, the biggest motivator for enforcing boundaries is to produce 1) a metric for progress and 2) a set of small, discrete goals.</p><h3>3. Methods of enforcing boundaries</h3><p>We had decided to enforce our engine boundaries. But in order to proceed, we had to clearly define what our goal was. What does it actually mean to enforce a boundary?</p><p>We settled on the definition of an enforced engine boundary as one with 0 instances of <em>inbound</em> and <em>outbound</em> leakage. Inbound leakage is when another part of the codebase reaches in and pilfers domain logic inside your engine. Outbound leakage is when your engine reaches outwards to pilfer another.</p><p>With our goal spelled out, our next course of action was clear. Google the problem!</p><p>We quickly discovered that enforcing engine boundaries isn’t a road well travelled. However, we did manage to find a few trailblazing blogs (links below) that were extremely helpful. It seemed there was precedent for two methods of boundary enforcement: isolated test suites and linting. We decided to experiment with both.</p><p>Our guinea pig was an engine built before we introduced the pattern of adaptors. The team that owns the domain had a spare few weeks to dedicate to the project and were keen on introducing adaptors and reducing leakage.</p><h4>3.1 — Isolating engine unit tests</h4><p>Your Rails app is going to autoload every class it can get its hands on. But do your tests need to? What if each engine had an independent set of unit tests that only loaded the constants available inside the engine? That way if your engine tried to sneak into another domain, the class it accessed would be unavailable and the tests would fail.</p><p>This seemed really intuitive. If you have a bunch of services, each one would have their own independent set of units tests. So why shouldn’t engines?</p><p>We set to work on our guinea-pig engine, determined to introduce an independent test suite that would enforce against outbound leakage.</p><h4>Adding tests to a Rails Engine</h4><p>We’ve always run the tests for our monolith from a single RSpec config. So we were surprised to learn that the <a href="https://edgeguides.rubyonrails.org/engines.html#testing-an-engine">conventional way to test an engine</a> is using a ‘dummy’ rails application. This is an empty, yet fully-functional, rails application used as a ‘mounting point’ for the engine during testing.</p><p>It seemed we’d generated our engine without the dummy app, so we needed to go back and regenerate it. Afterwards, we naively typed <em>rspec</em> and hoped nothing would break.</p><p>Turns out, a lot of things broke. This was our first learning: expect to spend a lot of time introducing and maintaining config.</p><p>At minimum, you’ll need to maintain separate <em>rails_helper.rb</em> and <em>spec_helper.rb</em> with only the config relevant to that specific engine and its dependencies. Your engine <em>.gemspec </em>needs to be in tip-top shape as well, with all gems manually imported with <em>require.</em></p><p>Once we’d solved the config problem, we were greeted with a towering list of failing tests. And we had our second learning: isolated test suites are brutal at catching boundary leakage.</p><h4>Isolated tests were effective</h4><p>The tests caught a lot more leakage than we expected. Some of the leakage was obvious, others hidden and implicit. Some were quick changes, while others took days of work for a single green test.</p><p>They were also a superb motivator. Slowly reducing the failing tests to 0 was addictive and ultimately adding it as CI step was a proud moment.</p><p>There was an additional benefit which we hadn’t expected. We’d known our engine was coupled — but what about our tests? It turns out our tests, specifically their use of <a href="https://github.com/thoughtbot/factory_bot">FactoryBot</a> factories, were in a much worse state than the code they were testing. Our factories were ripe with associations created across engine boundaries.</p><h4>What about inbound leakage?</h4><p>We’d had such a blast enforcing against outbound leakage for our guinea-pig engine, we were excited to do the same for inbound leakage. We eagerly sought the advice of our original inspiration, the awesome blog <a href="https://medium.com/@dan_manges/the-modular-monolith-rails-architecture-fb1023826fc4">Modular Monolith</a>.</p><p>It had an interesting approach. To illustrate, let’s return back to our cat grooming startup with their two engines: <em>CatClients</em> and <em>CatGroomers</em>. <em>CatClients</em> is a dependency of <em>CatGroomers</em> — to groom a cat you need to know that cats exist, but cats don’t need to know that the cat grooming profession exists.</p><p>To follow the blog’s approach, the test suite for <em>CatClients</em> would run in complete isolation. However, the test suite for <em>CatGroomers</em> would also load the <em>CatClients</em> engine as a dependency.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xiv-oZpdf6rYjhx3qw7YAQ.png" /></figure><p>In this instance, a portion of the tests inside the <em>CatGroomers</em> engine are acting as integration tests. If you test a <em>CatGroomers</em> method that fetches a cat, you run code inside the <em>CatClients</em> engine and can be confident that no integration issues occur for that user path.</p><p>That’s awesome. But how do you know that the <em>CatClients</em> domain hasn’t leaked into the <em>CatGroomers</em> domain? How do you know that a service in the <em>CatGroomers</em> domain isn’t ignoring adaptors and reaching in to grab <em>CatClients</em> domain models?</p><h4>Integration issues</h4><p>There is an immediate solution to this problem. If isolating the <em>CatClients </em>test<em> </em>protects against outbound leakage, we can protect against inbound leakage by isolating the <em>CatGroomers </em>tests<em>.</em></p><p>Therein lies another problem. If you have two engines that collaborate together, both unit tested by mocking the boundaries between each other, how can you gain confidence that there are no integration issues?</p><p>If these were truly two separate services, the solution would be clear. <em>CatGroomers </em>needs a separate set of integration tests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A1uZmVoxVSfp5v1ZEhndfA.png" /><figcaption>The ideal solution, but we’re not here yet.</figcaption></figure><p>While this does sound like the ideal long-term solution, the upfront commitment to write a new set of integration tests is high.</p><p>Is there a nearer-term method of measuring and enforcing inbound leakage?</p><h4>3.2 — Linting with Rubocop</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RgX5bBs9xWSUiFS_W6nHVw.png" /></figure><p>Enter our second experiment, courtesy of <a href="https://flexport.engineering/isolating-rails-engines-with-rubocop-210feaba3164">this amazing blog by Flexport</a>. The idea is pretty neat — just lint boundary leakage with Rubocop!</p><p>Flexport wrote three custom cops: one to prevent new models being created in the core <em>/app, </em>one to stop engines accessing code inside the core <em>/app</em>, and one to protect against access into an engine. They’ve even admirably <a href="https://github.com/flexport/rubocop-flexport">open-sourced</a> them.</p><p>Our main interest was the final cop that linted direct access into engines. This sounded like a great next step. We could measure and enforce inbound leakage for our guinea-pig engine while still keeping the existing tests that were inadvertently acting as integration tests.</p><p>We dug into the cop implementation. To our pleasant surprise, our first learning was that custom rubocop cops are pretty intuitive and a lot of fun. Definitely recommend playing around with them.</p><p>The idea behind the cop is fairly simple and replicable in our codebase. Essentially, the cop lints for two specific scenarios:</p><p>Uses of classes with an engine namespace:</p><pre><em>NotYourEngineNamespace::LeakyService.important_method</em></pre><p>And associations using an engine namespace:</p><pre><em>has_one :leaky_model, class_name: “NotYourEngineNamespace::LeakyModel”</em></pre><p>The simplicity was reassuring, but also brought us back to earth. Linting wasn’t going to be a silver bullet — the subtle leakage issues the isolated tests caught were going to fly under the radar.</p><p>This approach does have a lot of benefits: it’s super easy to get set up and starts to enforce against leakage from the get-go. It’s definitely a lighter touch than the isolated tests, which required a whole heap of config and didn’t enforce until we cleared the failing tests and added it as a CI step.</p><h3>What now?</h3><p>That’s the result of our experimentation so far. We’ve got a single engine enforcing against outbound leakage with an isolated test suite and enforcing against inbound leakage via a custom Rubocop cop.</p><p>Using Rubocop was a lot easier to get started and produced results immediately. However, the coverage wasn’t exhaustive. Isolating the tests was a pain in the arse, yet caught way more leakage than we ever imagined.</p><p>Overall, we’re satisfied with these approaches and plan to use a mix of both — Rubocop in the short term, working towards the goal of an independent test suite for each engine and a supporting set of engine integration tests.</p><p>Let us know if you have any questions or want to share your own views of enforcing Rails engine boundaries!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f856adb54e1d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/enforcing-modularity-inside-a-rails-monolith-f856adb54e1d">Enforcing Modularity inside a Rails Monolith</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Good to Wise: A Guide to Better Decisions]]></title>
            <link>https://medium.com/airtribe/from-good-to-wise-a-guide-to-better-decisions-8ed0b25ee0d7?source=rss----2469b1fab74c---4</link>
            <guid isPermaLink="false">https://medium.com/p/8ed0b25ee0d7</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[leadership-skills]]></category>
            <category><![CDATA[conversations]]></category>
            <category><![CDATA[communication]]></category>
            <category><![CDATA[meetings]]></category>
            <dc:creator><![CDATA[Dan Gooden]]></dc:creator>
            <pubDate>Wed, 22 Jan 2020 22:48:34 GMT</pubDate>
            <atom:updated>2020-01-22T22:49:12.437Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7CsJYfdxWirYqQJrB8xp6w.png" /></figure><p>At Airtasker, we face challenging and complex problems. Because our culture is highly collaborative, the quality of our conversations is critical for the quality of our work. Poor conversations lead to inadequate solutions that have unintended side effects. Conversations that meet the full complexity of the problem lead to solutions that are high quality and in the long term interests of the company.</p><p>Conversations occur in various ways and formats: online, informally in our social spaces, in 1:1’s and frequent meetings. Although decisions form through all these interactions, it’s in meetings where we typically decide together, often navigating multiple and opposing perspectives to do so. What we are seeking to do is make wise decisions.</p><blockquote>Wise decisions take into account what needs to be taken into account for long term beneficial outcomes — T. Atlee</blockquote><p>Recognising this, we’ve rolled out initiatives and education to improve the quality of conversations in our meetings and nurture wise decisions. In this article, I’ll detail warning signs for conversations that are less than healthy and provide four simple steps you can take to nurture conversations that encompass full complexity, rather than reductive or partial reasoning.</p><h3>Warning signs</h3><p>Have you noticed any of the following in your meetings?</p><ul><li>Meeting dominated by one or more individuals</li><li>Two people having a back and forth conversation that is irrelevant to most participants, hard to interject into, or becoming defensive</li><li>New idea shutdown</li><li>Forced agreement</li><li>Long monologues</li><li>Dead energy characterised by minimal participation and engagement</li></ul><p>These signs indicate meeting dynamics where participants are disengaged and struggling to contribute. This lack of participation can lead to decisions that miss essential insights and lack creativity and buy-in.</p><h3>Navigating difficult decisions</h3><p>It is easy to make the right decision when the solution is self-evident. But difficulty quickly ramps up when disagreement shows up. Often, this difficulty is felt as palpable discomfort in the room.</p><p>Although language is natural for us, skilfull communication isn’t, and even more so when we disagree. If a disagreement doesn’t lead us to disengage, we typically begin to debate. Debate is characterised by firmly held positions that are strongly argued. Entrenched positions make it difficult to listen well and find common ground. One side typically wins, but the outcome is often subpar because valuable insights from opposing views aren’t well integrated. The result doesn’t grasp the full complexity of the issue.</p><p>So what else is possible? Instead of debate, aim for a dialogic mode of communication.</p><blockquote>Dialogic communication is remaining in the tension between standing your own ground and being profoundly open to the other — W. Pearce</blockquote><p>Dialogic communication, or dialogue, naturally promotes creativity that can synthesise useful insights from multiple positions into new solutions. Dialogic communication doesn’t arise naturally (yet!), but you can design for it making its emergence more likely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*NNxyARSFPCNtBzmeCKMjEA.png" /><figcaption>In the parable of the blind men and the elephant, each blind man feels a different part of the elephant, believing they have the truth. Only when they put their insights together can they recognise what is before them is an elephant.</figcaption></figure><h3>Designing quality conversations</h3><p>Great group conversations can be designed for in the same way that great software and construction are the results of thoughtful design. Instead of an architect or an engineer, the designer for a conversation is known as a facilitator. It is their role to attend to the group’s process, model healthy communication and support the emergence of wise outcomes.</p><p>Airtasker has several engineering schools that enable developers who work on the same codebase to come together to discuss and decide technical convention and direction. Our engineering schools range in size from five to nearly twenty people. The school conversations, although useful, did struggle at times, especially when there was disagreement or a lack of clarity.</p><p>To improve this, we took steps to both bring attention to and raise the quality of the conversations held in schools.</p><h4>Four simple steps for dialogic communication</h4><ol><li>Recognising the importance of facilitation</li><li>Clarifying purpose</li><li>Shared airtime</li><li>Group norms</li></ol><h4>1. Recognising the importance of facilitation</h4><p>Although our schools had volunteers who convened the meetings, the role of facilitation wasn’t discussed or widely understood. Skilled facilitation develops with theory and practice, but there are basics that are simple and effective. To raise awareness of the importance of facilitation we ran a company-wide session on facilitation and conversation design. Following that we created a regular community of practice that allows those interested, to continue improving their skills.</p><p>Now facilitation is recognised as valuable, all school meetings have someone actively playing that role. During project meetings, we also see individuals volunteer to facilitate or use <a href="https://groupworksdeck.org/patterns/Guerrilla_Facilitation">guerrilla facilitation</a> if the group energy becomes chaotic or the subject material complexifies. This attention to the value of facilitation has allowed us to navigate difficult and complicated conversations that might not have been possible before.</p><h4>2. Clarifying <a href="https://groupworksdeck.org/patterns/Purpose">purpose</a></h4><p>Don’t underestimate the importance of clarifying the purpose of your meetings. For each school, we ran a reflection meeting where participants had the opportunity to reflect on why they were meeting and what they should expect to achieve together.</p><p>Ensuring everyone knows what they are seeking to do together enables people to participate comfortably and also push conversations towards desired outcomes. In one case, this attention to purpose led to a school renaming itself to better reflect its role as a learning and discussion space rather than a decision-making group, enabling a greater sense of shared purpose.</p><h4>3. <a href="https://groupworksdeck.org/patterns/Shared_Airtime">Shared airtime</a></h4><p>One of the most straightforward steps to bringing about dialogic communication is ensuring everyone can share their perspective and feel heard. We all participate in group conversations differently. Loud and confident individuals tend to speak the moment a break in the conversation presents (or even before!). Quieter individuals may require a pause of a few seconds before speaking. If you don’t specifically attend to shared airtime, insights held by softer voices are rarely heard, and your decisions will lack thoroughness. Shared airtime mechanisms are important once meetings reach six or more individuals but also help in hard conversations for smaller groups.</p><p>A common mechanism introduced at Airtasker was the speaking list. The facilitator manages a list of who is speaking next — if you wish to talk you indicate to the facilitator, who adds your name to the list, so you can speak in turn.</p><h4>4. Group norms</h4><p>Group norms are implicit or explicit behavioural rules that exist in groups. All of us follow norms in social situations we participate in, whether we recognise them or not. Examples norms are making decisions by majority voting, raising your hand to speak, and always going for a meal and drink at the close of the meeting.</p><p>Rather than letting group norms be implicit and unconscious, take time to set them explicitly. Explicit norms reduce friction by creating an upfront agreement on how to navigate disagreements and hard decisions. Norms also make it easier for participants to call out unhealthy group dynamics and reset the conversation.</p><p>Below are examples of norms from Airtasker’s teams and schools, covering decision making, meeting health, participation and action items.</p><ul><li>We use supermajority (more than 66% agree) voting as an initial mechanism, check for blocking concerns, and escalate if necessary</li><li>We avoid being distracted by laptops and phones (e.g. silent mode) during meetings</li><li>We save 10 minutes at the end of school meetings to share what we’re working on</li><li>We make sure everyone’s voice is heard. If a conversation between a few people gets too deep and not everyone wants to be involved we park it for another meeting/conversation</li><li>We leave the room explicitly understanding and agreeing on ownership and timeframes</li></ul><p>Our work on the quality of conversations led to energy shifts in schools, and a felt improvement also quantified in surveys. Importantly, care for conversation quality has taken on greater importance more broadly at the company. It’s hard to predict the long term impact of having wiser conversations, but for now, our meetings are more engaging and have better outcomes.</p><p>By raising the quality of our conversations, we create space for dialogic communication, and importantly, wise outcomes that grapple with the complexity of the challenges we face. If you’ve also been exploring this space, or have feedback, I’d love to hear from you. Please <a href="https://www.linkedin.com/in/dan-g-40191316/">reach out</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ed0b25ee0d7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/airtribe/from-good-to-wise-a-guide-to-better-decisions-8ed0b25ee0d7">From Good to Wise: A Guide to Better Decisions</a> was originally published in <a href="https://medium.com/airtribe">Technology @ Airtasker</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>