<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Dave Masino on Medium]]></title>
        <description><![CDATA[Stories by Dave Masino on Medium]]></description>
        <link>https://medium.com/@davemasino?source=rss-bfa6d1a41f76------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Dave Masino on Medium</title>
            <link>https://medium.com/@davemasino?source=rss-bfa6d1a41f76------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 11:55:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@davemasino/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Can Cortex Code be your team’s only AI harness?]]></title>
            <link>https://medium.com/@davemasino/can-cortex-code-be-your-teams-only-ai-harness-45330b63c9fd?source=rss-bfa6d1a41f76------2</link>
            <guid isPermaLink="false">https://medium.com/p/45330b63c9fd</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cortex-code]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[snowflake]]></category>
            <category><![CDATA[genai]]></category>
            <dc:creator><![CDATA[Dave Masino]]></dc:creator>
            <pubDate>Wed, 08 Jul 2026 16:43:26 GMT</pubDate>
            <atom:updated>2026-07-13T15:09:22.993Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>I spent 31 days, 272 million tokens, and 4,180 requests finding out.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*OrJ3KL_gLueIzwTu9s-v2g.png" /><figcaption>Photo by <a href="https://www.pexels.com/photo/back-view-of-a-boy-sitting-on-grey-chair-while-using-his-laptop-computers-4974916/">olia danilevich</a></figcaption></figure><p>As a Senior Director of Data and AI at Slalom, I’ve been developing with agentic tools like Claude Code and Codex since their respective launches, long enough to have a practical baseline for what engineers will actually adopt versus what stays a demo. When Snowflake invited my team into an early release program for <a href="https://docs.snowflake.com/en/user-guide/cortex-code/cortex-code">Cortex Code</a> (CoCo), I deliberately tested it against non-Snowflake workflows to see whether it could serve as a true daily driver.</p><p>CoCo is <a href="https://www.slalom.com/us/en/who-we-are/partners/snowflake">Snowflake’s</a> agentic AI coding assistant that plans, writes, and reviews code interactively rather than offering passive autocomplete. It ships in three forms: a terminal-based CLI, a desktop IDE, and an integrated experience within Snowsight.</p><p>This evaluation focuses on the CLI.</p><p>I went into it with a specific question: could it replace the separate AI coding harnesses that engineering teams already rely on? I wasn’t interested in whether it could supplement them for Snowflake-specific work. I wanted to know if it could serve as the daily driver for general engineering productivity.</p><p>Over three months, I logged 31 days of active use. Less than 5% touched Snowflake-native integrations. Here’s what I found.</p><h3>Immediate familiarity</h3><p>The first thing I noticed was how little ramp-up CoCo required. The terminal UI, agentic workflow model, and use of subagents for parallel work all felt immediately familiar to anyone who’s spent time in Claude Code. The design draws from the same philosophy, giving engineers an interactive plan-then-execute loop rather than passive autocomplete.</p><p>For technical leaders evaluating adoption, that familiarity matters. If your engineers already know how to work inside an agentic harness, the transition to CoCo is low friction. The interaction patterns (plan, confirm, execute, review) carry over directly.</p><p>That familiarity cuts both ways, though. CoCo was picking up my ~/.claude/AGENTS.md, a file with instructions specific to my Claude Code configuration that I didn&#39;t want applied here. The <a href="https://docs.snowflake.com/en/user-guide/cortex-code/cortex-code-desktop/instruction-files">instruction files documentation</a> showed where CoCo reads its own config, which pointed me to the fix: I created a global ~/.snowflake/cortex/AGENTS.md, with explicit instructions to ignore my Claude-specific global settings. CoCo reads this file across every project, so the two harnesses stay cleanly separated without per-repo configuration. If you&#39;re running CoCo as your only harness, this obviously won&#39;t be an issue for you. But if you&#39;re evaluating side by side, it&#39;s a good example of why understanding the documentation matters.</p><h3>Skills port over cleanly</h3><p>One of the first things I tested was whether CoCo’s skill system could absorb the custom workflows a team already relies on. Skills in CoCo live in .cortex/skills/ at the project level or ~/.snowflake/cortex/skills/ globally. It also reads .claude/skills/ directly, so existing skills are auto-discovered without moving them. The structure and behavior are functionally the same.</p><p>Skills don’t always drop in unchanged, though. Path conventions differ, and we wanted to vet each skill and optimize it for CoCo’s tooling. So we built a skill-to-cortex skill that handles the migration: it reads an existing skill, adapts it to CoCo&#39;s conventions, and validates the result. Twenty-four skills and their related documentation moved over in under an hour.</p><p>One early test involved running our jira-create-story skill through the migration, then gave it a one-sentence description of a documentation task. It produced this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vo-0PdN3IVSCRmPwPSbgTw.png" /></figure><p>That’s a production-ready ticket from a single prompt. The migration took minutes, and the output matched what we’d been getting from the same workflow in a different harness.</p><h3>Spec-driven planning: where it earns its place</h3><p>The capability that most impressed me was CoCo’s support for spec-driven workflows. I’m not talking about asking an AI to “write me a plan.” I mean an iterative loop where I draft a specification, CoCo critiques it, I refine it, and the tool converges on something precise enough to implement with confidence.</p><p>This iterative planning loop is where I saw the most leverage. On one task, I went through four rounds of spec refinement before writing any code. The implementation landed cleanly on the first pass because the spec had already resolved the ambiguity. Here’s what an implementation-ready plan looks like after that refinement process, graded by a custom plan-grade skill running inside CoCo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-NDv_wdzWEry1aBQrgN69w.png" /></figure><p>That loop works because each round builds on the last. The spec sharpens incrementally, so by the time you implement, the ambiguity is already resolved.</p><p>For technical leaders, this is the workflow pattern worth paying attention to. Iterating on a plan costs less than iterating on code, both in tokens and in engineering time. The payoff is an implementation-ready artifact that lands cleanly on the first pass.</p><h3>Knowledge work, not just code</h3><p>One example worth calling out: I fed CoCo the official <a href="https://learn.snowflake.com/en/certifications/snowpro-GenAI/?pdf_name=SnowProGenAIStudyGuide.pdf">SnowPro Specialty: Gen AI</a> exam study guide (a dense PDF of objectives, domain weightings, and topic outlines) and asked it to produce a structured study guide tailored to my learning style. It read the PDF, built a plan organized by the four exam domains weighted by their percentage of the test, then generated per-domain markdown files with key distinctions, exam tips, decision frameworks, and documentation references. The output was a complete, navigable study resource: not a summary, but a purpose-built learning artifact I’m actively using to prepare for the certification. I’ve <a href="https://github.com/davem-slalom/snowpro-genai-studyguide">open-sourced the result</a> if you’re preparing for the same exam.</p><p>That’s not a coding task. It’s knowledge work: reading a complex source document, identifying what matters, structuring it for a specific use case, and producing something better than what I started with. I didn’t have to leave my terminal or open a different tool to do it.</p><p>None of these workflows required CoCo’s Snowflake connectivity. No SQL execution, no semantic views, no data pipeline tooling. They’re the everyday work of an engineering leader who still builds, and CoCo handled all of them without sending me back to another tool.</p><h3>Documentation as a first-class workflow</h3><p>Documentation revealed a different kind of leverage: unlike a general-purpose writing tool that needs you to re-explain your codebase every session, the harness brings that context to every draft automatically.</p><p>A good example: my team published a <a href="https://medium.com/slalom-blog/snowflake-native-agentops-from-story-to-delivery-at-scale-ef9ffcfce26b">Snowflake-native AgentOps workflow</a> that we use for agentic delivery at scale. The workflow had supporting documentation, but it needed work. The newcomer onboarding guide, template authoring reference, and implementation flows walkthrough all needed expansion and refinement. I used CoCo to improve all three. The process was iterative: I’d outline a section, CoCo would draft it with full context of the existing codebase and workflow conventions, I’d refine, and we’d converge on something a new team member could actually follow. What would have been a tedious solo writing exercise became a focused conversation with a tool that already understood the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v5D8y9a3kGjUCkPaxlkN3w.png" /></figure><p>That same loop produced what you’re reading now. I wrote this post inside CoCo, reviewing it against Slalom’s editorial guidelines via a blog-author skill, and refining it in the same context where the code examples and screenshots live. The feedback loop is immediate because the writing, the review, and the adjustment all happen without leaving the terminal.</p><p>For teams that treat documentation as a first-class engineering artifact (and they should), this matters. Style guides, editorial standards, and review checklists can all live as skills that run on demand. The harness becomes an editorial partner alongside a code generator.</p><h3>Where it’s still maturing</h3><p>Cortex Code is under active development, and the iteration pace is worth calling out.</p><p>Early in my evaluation, I tried converting a project that used .claude/rules/ and CoCo told me it wasn&#39;t supported. I moved on with AGENTS.md and didn&#39;t look back until I discovered months later that support had been added without me noticing. If you looked at CoCo a few months ago and noted gaps, it&#39;s worth a closer look today.</p><p>What’s genuinely still growing: enterprise integrations work through MCP (<a href="https://medium.com/slalom-blog/what-is-mcp-and-why-should-you-care-c26888575511">Model Context protocol</a>), an open standard that connects to tools like GitHub, Jira, Slack, and databases. Community MCP servers exist for many services, but the pre-built gallery isn’t as deep as what you’d find in a more established ecosystem. Teams with complex integration requirements should evaluate what’s available for their specific stack.</p><p>None of these were blockers for my evaluation. But a technical leader planning a team-wide rollout should assess where the gaps are for their specific workflows and where the roadmap is headed.</p><h3>What made the evaluation effective</h3><p>One factor that accelerated my evaluation: early access programs with fast feedback loops. When something wasn’t working as expected, I could surface it directly to Snowflake’s team and get clarity quickly. That kind of access made it possible to evaluate the tool’s real potential without getting stuck on early rough edges. If your organization is considering adoption, it’s worth asking whether similar programs are available.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*MNdmEWeCVsB9vUzt" /></figure><h3>The strategic case for consolidation</h3><p>Every tool your engineers context-switch between is a workflow they have to maintain, a set of quirks they have to remember, and a body of customization that doesn’t port. Cortex Code makes consolidation worth evaluating because it clears the bar on general-purpose engineering productivity. It handles planning, coding, Git, documentation, and workflow automation, which means your team’s custom skills work everywhere they work, muscle memory transfers, and context stays in one place instead of fragmented across tools that don’t talk to each other.</p><p>For a team already invested in Snowflake, that consolidation compounds. One tool, one set of skills to maintain, and the Snowflake-native capabilities (SQL authoring, semantic views, data pipeline tooling) come as a bonus on top of a harness that’s already earning its place through daily engineering work.</p><p>If you want to test this yourself, <a href="https://docs.snowflake.com/en/user-guide/cortex-code/cortex-code">Cortex Code is available now</a>. Bring your own skills, run it against your real workflows, and decide whether the consolidation case holds for your team.</p><p><a href="https://www.slalom.com/us/en"><em>Slalom</em></a><em> is a fiercely human business and technology consulting company that leads with outcomes and teams with leaders, bringing more together. </em><a href="https://www.slalom.com/us/en/who-we-are/partners/snowflake"><em>Learn how</em></a><em> we partner with Snowflake to help organizations modernize engineering, accelerate AI adoption, and build data-driven solutions that deliver measurable business outcomes.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45330b63c9fd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The overlooked AI skill for data engineers: Git]]></title>
            <link>https://medium.com/@davemasino/the-overlooked-ai-skill-for-data-engineers-git-b349bb9ba78f?source=rss-bfa6d1a41f76------2</link>
            <guid isPermaLink="false">https://medium.com/p/b349bb9ba78f</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Dave Masino]]></dc:creator>
            <pubDate>Thu, 16 Apr 2026 18:12:34 GMT</pubDate>
            <atom:updated>2026-04-16T18:12:34.323Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>AI is speeding up data engineering. Git is what keeps it under control.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*a-cXpd2F22dX0nhAJuHzjA.png" /><figcaption>Photo by <a href="https://www.pexels.com/photo/back-view-of-a-people-looking-the-monitor-7988759/">Mikhail Nilov</a></figcaption></figure><p>AI can now help data engineers produce SQL, tests, pipeline changes, and refactors faster than most teams can fully reason about them. That speed is useful right up until someone has to untangle which experiment belongs in production, which diff is safe to merge, and whether the branch contains the work they think it does.</p><p>After working across numerous data and software teams, I’ve come to see <a href="https://git-scm.com/">Git</a> as one of the most overlooked AI skills for data engineers. Git was already foundational before AI coding tools showed up. What changed is the cost of weak habits: higher output means more noisy history, harder-to-review diffs, and more operational risk.</p><p>For data engineers, the stakes are especially high. They touch SQL models, orchestration logic, notebook experiments, infrastructure definitions, and production data movement. A messy change in one of those places does not just slow down a teammate. It can break a pipeline, muddy lineage, or make it harder to explain what changed and why.</p><h3>Who this is for</h3><p>This post is for data engineers who are using tools like Codex and Claude Code to generate more code than they used to. Some come from software engineering backgrounds and already have strong Git habits. Others come from analytics, BI, or business analysis paths, where Git may not have been part of the daily workflow. Readers in the second group may feel the need more immediately, but the core point applies to both: as AI increases output, Git becomes more important, not less.</p><p>I don’t think every data engineer needs to become a Git purist. I believe that if AI expands what you can build, Git becomes even more important as the mechanism that keeps your work understandable, reviewable, and recoverable.</p><h3>Why AI raises the stakes</h3><p>Before AI coding tools became common, many teams were naturally limited by how quickly a human could write and refactor code. That limit was frustrating, but it also kept change manageable. Now a data engineer can <a href="https://www.slalom.com/us/en/services/artificial-intelligence/ai-accelerated-engineering">ask for a dbt model, an Airflow DAG update, a transformation script, a test file, and a few refactors in one sitting</a>. That is useful. It is also exactly why Git fluency matters more.</p><p>AI increases the chance that you will:</p><ul><li>Generate more changes than you can comfortably reason about at once</li><li>Run multiple experiments in parallel</li><li>Accept a “mostly right” patch that still needs review</li><li>Lose track of which version solved which problem</li><li>Create a diff that is technically valid but hard for a teammate to review</li></ul><p>None of that is an argument against AI. It’s an argument for handling AI-assisted work with even stronger version control habits than before.</p><h3>Why this is a data engineering problem</h3><p>Data engineering work often lives in the uncomfortable middle between analytics and software engineering. That’s part of what makes the role interesting. It also means teams often have mixed backgrounds and mixed habits.</p><p>Some data engineers already think in branches, commits, and pull requests. Others have spent more time in SQL editors, BI tools, spreadsheets, or notebooks, where versioning has historically been looser. AI tools are flattening that gap by letting both groups produce code more easily across dbt, orchestration code, notebooks, CI configuration, and infrastructure definitions. That’s a good thing. But when code generation becomes easier than source control discipline, the team gets new failure modes.</p><p>I have seen the pattern in small ways: a useful experiment gets mixed into a production branch, a generated refactor lands without a clear rationale, or a teammate cannot tell whether a change is safe because the history is noisy. In a data platform, those are not just workflow annoyances. They affect trust in pipelines and lineage.</p><h3>The Git fundamentals that matter most</h3><p>This isn’t a full Git tutorial. I think data engineers using AI need a small working set of Git fundamentals that keeps fast-moving work under control from experiment to review.</p><p>At a minimum, that includes:</p><ul><li>Starting each AI-assisted task on a branch with one clear purpose</li><li>Committing your work frequently enough to recover safely, then cleaning up the history before review</li><li>Opening pull requests that explain the operational impact, especially when SQL, tests, DAGs, and config change together</li></ul><p>The first habit is keeping work isolated and recoverable. That starts with switching context cleanly, then using branching to keep experiments on their own path. AI-assisted development often means trying one idea, abandoning it, and then jumping to another. If you can’t move between working states cleanly or keep experiments on their own branches, you’ll end up with half-finished changes in the wrong place and no reliable mental model of what belongs where. Branches let you explore quickly without polluting shared work.</p><p>On one team I worked with, branch confusion cost us several days of productivity. The team had mixed Git experience, and by the time we were untangling what happened, it was difficult to tell with confidence whether every change had been captured and carried forward correctly. It was ordinary version-control confusion, and it still slowed real work down for days.</p><p>The second habit is keeping history understandable as the branch evolves. That’s where merging and rebasing start to matter. I don’t think every team needs to be doctrinaire about either one, but data engineers should understand what role each is playing. Merging is how isolated work becomes shared reality. Rebasing helps you keep a branch current and shape a cleaner story before someone else has to review it.</p><p>I saw the same pattern at a smaller scale in my own work. While using AI to draft user stories, I committed frequently so I could roll back safely if the output drifted. By the time I was ready to open a pull request, I had a pile of commits that reflected my process but not a reviewer-friendly story. An interactive rebase turned that history into a few logical units of work and made the review much easier to follow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*ReByLDtGgSv-gz2WilnNmQ.png" /><figcaption>Interactive rebase after fixing an Airflow DAG issue</figcaption></figure><p>The third habit is treating pull requests as the point where judgment becomes visible. In AI-assisted work, the question isn’t just “Does this run?” but also “Is this understandable, safe, and aligned with how our team wants changes to land?” A good pull request answers those questions with a scoped diff, a coherent history, and a clear explanation of what changed and why.</p><h3>What AI can do, and what it can’t</h3><p>One reason this topic gets overlooked is that modern tools can perform many Git tasks for you. They can create a branch, suggest a rebase, summarize a diff, and even open a pull request. That’s useful. I want those tools to keep improving.</p><p>But delegation isn’t the same as understanding. If an AI tool rebases your work, you still need to know whether the result makes sense. If it opens a pull request, you still need to know whether the diff tells a coherent story. If it merges something cleanly, you still need to decide whether it should have been merged at all.</p><p>That’s the core point for me: AI can automate Git actions, but it can’t remove the need for judgment. Data engineers don’t need to memorize every command, but they do need to recognize what good looks like.</p><h3>What good looks like</h3><p>In practice, “good” usually looks pretty boring — and that’s a compliment. Your work lives on a branch with a clear purpose. Your diff is scoped tightly enough that another engineer can review it without detective work. Your branch is current with the latest shared code. Your pull request explains what changed and why. And if an AI tool helped generate the work, you can still point to what belongs in the change and what doesn’t.</p><p>When those habits are in place, Git becomes more than a safety mechanism. It becomes part of what lets a team get real value from AI-assisted development. Cleaner branches, reviewable diffs, and clearer pull requests make it easier to hand work across engineers, move ideas from experiment to production, and adopt AI tools without letting speed turn into confusion.</p><p>That’s the kind of boring reliability AI needs around it. Without it, the benefit of faster code generation gets eaten by confusion, rework, and mistrust.</p><h3>Closing</h3><p>Git deserves more airtime in AI skill conversations for data engineers because AI is increasing the speed and volume of code change, and Git is one system that keeps that change manageable.</p><p>If you’re a data engineer <a href="https://www.slalom.com/us/en/insights/ai-research-outlook-2026">leveling up in the AI era</a>, start here: learn how to switch context cleanly, work in branches, understand merges and rebases, and treat pull requests as a real checkpoint. If AI increases how much you can produce in a day, your Git habits need to improve at the same rate. That’s not just how you stay in control. It’s how you and your team adopt AI faster, collaborate more cleanly, and turn experiments into production-ready changes.</p><p><a href="https://www.slalom.com/us/en"><em>Slalom</em></a><em> is a fiercely human business and technology consulting company that leads with outcomes and teams with leaders, bringing more together.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b349bb9ba78f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>