<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Indicium AI</title>
    <description>The latest articles on DEV Community by Indicium AI (indiciumai).</description>
    <link>https://dev.to/indiciumai</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F14256%2Fd8d78488-6358-4e6a-83c3-b85ca547394d.jpeg</url>
      <title>DEV Community: Indicium AI</title>
      <link>https://dev.to/indiciumai</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/indiciumai"/>
    <language>en</language>
    <item>
      <title>Build without limits - SDLC Briefing, #6</title>
      <dc:creator>Ricardo Sueiras</dc:creator>
      <pubDate>Mon, 16 Nov 2026 08:19:20 +0000</pubDate>
      <link>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-6-5ekm</link>
      <guid>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-6-5ekm</guid>
      <description>&lt;p&gt;&lt;em&gt;Hi! I am Ricardo Sueiras, leading SDLC transformation at Indicium AI. That means I get to  work with customers and help them understand how to use agentic AI to build software. New tools, practices and opinions turn up every week, and Build without Limits cuts through the noise. In each edition we put together a short, curated briefing on what's worth reading, watching and worth trying. You can skim it in five minutes and dive deeper wherever something catches your eye.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Top of Mind
&lt;/h2&gt;

&lt;p&gt;Top of mind this week has been integrating quality into the harness. Two posts came up that are worth reading that cover some of the things I am seeing. First up, &lt;a href="https://highimpactengineering.substack.com/p/we-handed-testing-to-ai-here-is-what" rel="noopener noreferrer"&gt;We handed testing to AI. Here is what stayed human&lt;/a&gt; which continues Roman's journey on how to unlock review and flow bottlenecks in agentic engineering. There are a lot of great observations within this post, and I like the conclusions he draws at the end &lt;em&gt;"The bottleneck keeps moving. This time, the way through it is not more testers, but better systems around the ones we have."&lt;/em&gt;. On a similar vein, Vincent shares his ideas on &lt;a href="https://www.vincentschmalbach.com/how-to-stop-a-coding-agent-from-weakening-or-faking-tests-to-make-them-pass/" rel="noopener noreferrer"&gt;How to Stop a Coding Agent From Weakening or Faking Tests to Make Them Pass&lt;/a&gt; and I have tried some of these techniques so am fully supportive. Essential reading to give yourself more confidence in the tests your agents run.&lt;/p&gt;

&lt;h2&gt;
  
  
  Must reads this week
&lt;/h2&gt;

&lt;p&gt;These were my favorite posts this week.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://claude.dev/blog/which-claude-model-should-you-build-with" rel="noopener noreferrer"&gt;Which Claude model should you build with? Fable, Opus, Sonnet, or Haiku&lt;/a&gt; helps answer one of the most common things we help engineering teams with, how to think about models and the tasks they are doing.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://surgehq.ai/blog/benchmarking-coding-agent-harnesses" rel="noopener noreferrer"&gt;Agent Harnesses. Thinking Harder Beat All of Them.&lt;/a&gt; a post that suggests setting a models thinking level in Claude Code, produces better outcomes that the various elaborate configurations that we create. This one raised my eyebrows more than a few times.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://arxiv.org/abs/2611.12122?fbclid=IwRlRTSAVjDolleHRuA2FlbQIxMQBwZG9mBWZkaWQWUSFwSucQsoR9xVlowp1zGRaX7IbAYnNydGMGYXBwX2lkCjY2Mjg1NjgzNzkAAR8ebvvq-U86Lu0InMyS3r38EUAHHesQXkVblLL04isfyqYYR-QFCLWJ3Iideg_aem_Jka8IyrTjRIBCrFEXaq7Kw" rel="noopener noreferrer"&gt;System Optimizations for Cost-Efficient Agent Harnesses&lt;/a&gt; a research paper that I came across this week that took a look at how to optimise your harness.It shares five techniques to optimise cost in agent executions. First, we find reading existing context is the largest source of agent cost in real-world executions even with caching, taking up to 73% of the total cost. Second, tool calls incur significant cost without increasing the token count, causing up to a 26× cost increase at the same token count. Third, tool call outputs are often information sparse, and the agent uses only 27% of tools' outputs on average. Fourth, agents often invest many turns in filesystem exploration, and up to 89% of agent turns can be spent searching the filesystem in retrieval-heavy tasks. Finally, agent traces contain a large number of parallel subtasks, and we find on average 1.3 to 2.7 independent subtasks that can run concurrently to reduce context sharing across subtasks. Read the paper to dive into each of these.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://alfy.blog/2026/11/08/webmcp-explained-with-a-to-do-app.html?" rel="noopener noreferrer"&gt;WebMCP, explained with a todo app&lt;/a&gt; if you have not yet dipped your toe into WebMCP, then why not take a look at this post and be inspired to try it out. WebMCP provides agents with a robust framework in how to interact with your web applications, that borrows from Model Context Protocol (MCP).&lt;/p&gt;

&lt;h2&gt;
  
  
  Watch this
&lt;/h2&gt;

&lt;p&gt;Bartosz Ocytko, Executive Principal Engineer at Zalando, shares three years of lessons of how they were able to scale agentic engineering across 2,000 developers and 150 engineering teams.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/niMX5QHChlA" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  Tools to try out
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Third-party tools links are provided as-is. They belong to their owners, follow their own licenses, and are used at your own risk.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/aws/aws-emulator" rel="noopener noreferrer"&gt;aws-emulator&lt;/a&gt; is an official emulator of AWS services from Amazon, that joins Localstack and floci in allowing developers to run everything locally. This week my timeline has been full of developers experimenting what you can do. So far, the responses have been mostly good. One thing to bear in mind is that its not intended as a tool for testing security, so IAM support is limited.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/githubnext/ace" rel="noopener noreferrer"&gt;ace&lt;/a&gt; is an experimental new tool from Github that explores what multiplayer agentic development might look like. Defo check the docs on this one (start&lt;a href="https://ace.githubnext.com/" rel="noopener noreferrer"&gt;here&lt;/a&gt;). Still getting my head around this one, so if you are ahead of me, I would love to chat!&lt;/p&gt;

&lt;p&gt;Not a tool/repo, but Apple now lets you run XCode inside Claude Code which means you can do things like build, run and test your app, render SwiftUI previews, drive simulators and real iPhones, read build logs and errors, or search Apple's developer docs. You will need XCode on your Mac (latest version) and then use this.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Install in Claude Code: /plugin install xcode@claude-plugins-official
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I enjoyed reading and trying out some of the stuff in &lt;a href="https://cellcog.ai/blog/apple-xcode-plugin-claude-code/" rel="noopener noreferrer"&gt;Apple's Xcode Plugin for Claude Code: What It Does&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  From the field
&lt;/h2&gt;

&lt;p&gt;This week I have been exploring the relationship and impact of developer experience on organisations that are adopting agentic AI.&lt;/p&gt;

&lt;p&gt;Conway showed organisations the impact of structure on its ability to build applications. Over the past ten years and the move the Cloud and cloud native architectures, this caused many organisations to rethink their structure (Amazon) or implement new systems (reverse Conway manoeuvre). &lt;a href="https://en.wikipedia.org/wiki/DevOps_Research_and_Assessment" rel="noopener noreferrer"&gt;Accelerate&lt;/a&gt; (and many studies since) showed that organisations that had invested in developer experience, were the organisations able to ride the wave of innovation and value generation that Cloud promised.&lt;/p&gt;

&lt;p&gt;In the age of agentic AI, Conway has been dialled up to 11, with pressure points surfacing up across the software development lifecycle. Agentic AI tools have the potential to improve the developer experience like no other previous technology. Agentic engineering however, depends and leans heavily on strong foundations. Those foundations (and investments) that organisations should have been building during the Cloud era.&lt;/p&gt;

&lt;p&gt;This surfaces up at customers in many different manifestations. It might be pressure points surfacing up as one area moves faster and others fail to keep up, or it is equally where they are looking to apply AI to fix problems they already have across their SDLC. When zooming out, we see the same challenges that lead back to poor or underinvested developer experience being at the root of the problem. &lt;/p&gt;

&lt;p&gt;Organisations that have invested in a strong developer experience are going into the AI SDLC era well placed to take advantage of the benefits agentic AI brings. Its an area that organisations should start to reflect where they are, and then plan investments. This is beginning to happen, and I am seeing a growth in developer experience teams being formed across business right now.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&amp;amp;arnumber=11679527" rel="noopener noreferrer"&gt;Developer Productivity for Humans: Navigating the Tensions of AI in the Software Development Lifecycle&lt;/a&gt; is well worth reading to find out more about this.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;If you enjoyed this, then remember to subscribe to the IndiciumAI blog so that you can keep up to date with future editions of this newsletter, as well as other great content that technologists at IndiciumAI will publish.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>developers</category>
    </item>
    <item>
      <title>I tagged PII only in bronze and Unity Catalog masked it all the way to gold</title>
      <dc:creator>Vinícius de Carvalho</dc:creator>
      <pubDate>Thu, 12 Nov 2026 13:49:35 +0000</pubDate>
      <link>https://dev.to/indiciumai/i-tagged-pii-only-in-bronze-and-unity-catalog-masked-it-all-the-way-to-gold-2oo0</link>
      <guid>https://dev.to/indiciumai/i-tagged-pii-only-in-bronze-and-unity-catalog-masked-it-all-the-way-to-gold-2oo0</guid>
      <description>&lt;p&gt;Most breaches don't start where the protection is. An analyst copies customer data out of the warehouse into a shared folder or a spreadsheet for a quick analysis, and the copy outlives the reason it was made. Anyone who can open that folder now has the data, whether or not they ever had warehouse access. IBM found &lt;a href="https://www.ibm.com/think/insights/hidden-risk-shadow-data-ai-higher-costs/" rel="noopener noreferrer"&gt;shadow data&lt;/a&gt;, copies nobody tracks, in more than a third of breaches in 2024. The same gap exists inside the warehouse. Teams mask or tokenize the columns they flagged as sensitive, and the masks work, but each mask is attached to a column in one table. A table built from that column is a new table, and it starts with no protection. Protection stays where it was applied; it doesn't travel with the data.&lt;/p&gt;

&lt;p&gt;Health data makes the gap hardest to ignore. It is a special category under both the GDPR and Brazil's LGPD, and it is also the most expensive data to lose. IBM's &lt;a href="https://www.csoonline.com/article/567697/what-is-the-cost-of-a-data-breach-3.html" rel="noopener noreferrer"&gt;Cost of a Data Breach Report 2026&lt;/a&gt;, which covers breaches from March 2025 to February 2026, puts healthcare first at $6.64M per breach, with financial services close behind at $6.29M:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpwf6iddkf6weaeoutv82.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpwf6iddkf6weaeoutv82.png" alt="Bar chart of the average cost of a data breach by industry, March 2025 to February 2026: healthcare $6.64M, financial $6.29M, industrial and technology $5.50M each, down to transportation at $4.50M" width="800" height="490"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In a lakehouse, that copy is usually a derived table: someone builds a table with &lt;code&gt;full_name&lt;/code&gt; and &lt;code&gt;ssn_hash&lt;/code&gt; from columns you classified, and the classification stays behind. So I tested whether Unity Catalog can make the protection follow the data. I tagged 10 columns in bronze, touched nothing downstream, and checked silver and gold.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Result: 33 of 33 expected tags arrived on the derived columns within about 4 seconds, and the masks applied to them. Not a single &lt;code&gt;SET TAGS&lt;/code&gt; outside bronze.&lt;/strong&gt; The way there also showed one trap that destroys data.&lt;/p&gt;

&lt;h2&gt;
  
  
  The feature: tag propagation in Databricks
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Tag propagation&lt;/strong&gt; makes governed tags follow column lineage, from a source column to every column derived from it. Combined with &lt;strong&gt;ABAC policies&lt;/strong&gt;, column masks defined once on the catalog for any column carrying a tag, a derived table is masked the moment it exists.&lt;/p&gt;

&lt;p&gt;Before it works:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;It is in Beta. A workspace admin enables it on the &lt;strong&gt;Previews&lt;/strong&gt; page.&lt;/li&gt;
&lt;li&gt;It is switched on &lt;strong&gt;per governed tag&lt;/strong&gt;: Catalog → Govern → Governed Tags → Configure → Tag propagation.&lt;/li&gt;
&lt;li&gt;You need &lt;code&gt;MANAGE&lt;/code&gt; on the tag, and the writes must run on &lt;strong&gt;serverless&lt;/strong&gt; compute.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuj3d1pjz3lonqpq6plby.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuj3d1pjz3lonqpq6plby.png" alt="The governed tag page for sap.PersonalData.isPotentiallyPersonal, with tag propagation enabled and true as the default propagation value" width="800" height="467"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Details in the &lt;a href="https://docs.databricks.com/aws/en/admin/governed-tags/tag-propagation" rel="noopener noreferrer"&gt;tag propagation docs&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How I tested it
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Setup&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Data:&lt;/strong&gt; &lt;a href="https://synthetichealth.github.io/synthea/" rel="noopener noreferrer"&gt;Synthea&lt;/a&gt; synthetic health records (patients, encounters, providers), in a bronze → silver → gold medallion. None of it is real, so mistakes are cheap.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Platform:&lt;/strong&gt; Databricks Free Edition, serverless SQL warehouse. The SQL ran both ad hoc and as Databricks Asset Bundle jobs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Classification:&lt;/strong&gt; two Databricks-provided governed tags that map to LGPD's two categories, &lt;code&gt;sap.PersonalData.isPotentiallyPersonal&lt;/code&gt; (art. 5, I) and &lt;code&gt;sap.PersonalData.isPotentiallySensitive&lt;/code&gt; (art. 5, II). Ten columns tagged in bronze, in one file. &lt;code&gt;PASSPORT&lt;/code&gt; carries both tags on purpose. &lt;code&gt;CITY&lt;/code&gt;, &lt;code&gt;GENDER&lt;/code&gt; and &lt;code&gt;HEALTHCARE_EXPENSES&lt;/code&gt; stay untagged as negative controls.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write paths:&lt;/strong&gt; five silver objects, one per operation: CTAS with derived columns (&lt;code&gt;concat_ws&lt;/code&gt;, &lt;code&gt;right()&lt;/code&gt;, &lt;code&gt;sha2()&lt;/code&gt;), CTAS with a JOIN, &lt;code&gt;INSERT ... SELECT&lt;/code&gt; into a pre-existing table, &lt;code&gt;MERGE&lt;/code&gt;, and a view. Then three gold tables on top of silver, including a &lt;code&gt;GROUP BY&lt;/code&gt; on a sensitive column.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Masks:&lt;/strong&gt; four catalog-level ABAC policies: redact (&lt;code&gt;***&lt;/code&gt;), pseudonymize (SHA-256), remove (&lt;code&gt;NULL&lt;/code&gt;), and one for columns with both tags.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Personas:&lt;/strong&gt; four account groups, combined into five personas, from no access to the pipeline identity that writes everything in clear text.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Tagging is one statement per column, in bronze only:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="k"&gt;ALTER&lt;/span&gt; &lt;span class="k"&gt;TABLE&lt;/span&gt; &lt;span class="n"&gt;synthea&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;bronze&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;patients&lt;/span&gt; &lt;span class="k"&gt;ALTER&lt;/span&gt; &lt;span class="k"&gt;COLUMN&lt;/span&gt; &lt;span class="no"&gt;SSN&lt;/span&gt;
  &lt;span class="k"&gt;SET&lt;/span&gt; &lt;span class="no"&gt;TAGS&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'sap.PersonalData.isPotentiallyPersonal'&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s1"&gt;'true'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A policy matches tags, not tables, which is what lets it reach silver and gold:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="k"&gt;CREATE&lt;/span&gt; &lt;span class="k"&gt;OR&lt;/span&gt; &lt;span class="k"&gt;REPLACE&lt;/span&gt; &lt;span class="no"&gt;POLICY&lt;/span&gt; &lt;span class="n"&gt;pii_personal_redact&lt;/span&gt;
&lt;span class="k"&gt;ON&lt;/span&gt; &lt;span class="no"&gt;CATALOG&lt;/span&gt; &lt;span class="n"&gt;synthea&lt;/span&gt;
&lt;span class="k"&gt;COLUMN&lt;/span&gt; &lt;span class="no"&gt;MASK&lt;/span&gt; &lt;span class="n"&gt;synthea&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;governance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;mask_redact&lt;/span&gt;
&lt;span class="k"&gt;TO&lt;/span&gt; &lt;span class="sb"&gt;`account users`&lt;/span&gt;
&lt;span class="k"&gt;EXCEPT&lt;/span&gt; &lt;span class="sb"&gt;`synthea_pipeline`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sb"&gt;`synthea_pii_readers`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sb"&gt;`synthea_analysts`&lt;/span&gt;
&lt;span class="k"&gt;FOR&lt;/span&gt; &lt;span class="no"&gt;TABLES&lt;/span&gt;
&lt;span class="k"&gt;MATCH&lt;/span&gt; &lt;span class="no"&gt;COLUMNS&lt;/span&gt; &lt;span class="nf"&gt;has_tag_value&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'sap.PersonalData.isPotentiallyPersonal'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'true'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
          &lt;span class="k"&gt;AND&lt;/span&gt; &lt;span class="k"&gt;NOT&lt;/span&gt; &lt;span class="nf"&gt;has_tag_value&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'sap.PersonalData.isPotentiallySensitive'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'true'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;
&lt;span class="k"&gt;ON&lt;/span&gt; &lt;span class="k"&gt;COLUMN&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A user must never resolve to two different masks on the same column, or the query fails. The four policies cover three disjoint sets of tags. Two of them, redact and pseudonymize, share a set and split it by principal: redact skips &lt;code&gt;synthea_analysts&lt;/code&gt;, pseudonymize applies only to &lt;code&gt;synthea_analysts&lt;/code&gt;, and &lt;code&gt;synthea_pii_readers&lt;/code&gt; is exempt from both.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Measurement&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Propagation test.&lt;/strong&gt; The 33 column/tag pairs I expect in silver and gold live in a table. A &lt;code&gt;FULL OUTER JOIN&lt;/code&gt; against &lt;code&gt;information_schema.column_tags&lt;/code&gt; labels each one &lt;code&gt;OK&lt;/code&gt;, &lt;code&gt;MISSING&lt;/code&gt; or &lt;code&gt;EXTRA&lt;/code&gt;, and any &lt;code&gt;MISSING&lt;/code&gt; calls &lt;code&gt;raise_error()&lt;/code&gt;, which fails the job.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Integrity check.&lt;/strong&gt; Distinct values against row count on hashed columns after every build.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Persona matrix.&lt;/strong&gt; One query per persona reads a value from each kind of column and classifies it as clear, hash, &lt;code&gt;***&lt;/code&gt; or &lt;code&gt;NULL&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Results
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;What&lt;/th&gt;
&lt;th&gt;Result&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Tags on silver and gold&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;33/33 OK, 0 EXTRA&lt;/strong&gt;, no &lt;code&gt;SET TAGS&lt;/code&gt; outside bronze&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Write paths covered&lt;/td&gt;
&lt;td&gt;CTAS, JOIN, &lt;code&gt;INSERT ... SELECT&lt;/code&gt;, &lt;code&gt;MERGE&lt;/code&gt;, view, and the second hop into gold&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Time to propagate&lt;/td&gt;
&lt;td&gt;within about &lt;strong&gt;4 seconds&lt;/strong&gt; of the last write&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Bundle jobs on serverless&lt;/td&gt;
&lt;td&gt;4 runs, 33/33 each, 30 to 50 seconds per run&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rebuild with &lt;code&gt;CREATE OR REPLACE&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;all 33 tags kept&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Negative controls&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;city&lt;/code&gt;, &lt;code&gt;gender&lt;/code&gt;, &lt;code&gt;healthcare_expenses&lt;/code&gt; stayed untagged&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;What each persona saw, set by group membership:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Groups&lt;/th&gt;
&lt;th&gt;Personal (SSN, name)&lt;/th&gt;
&lt;th&gt;Sensitive (race)&lt;/th&gt;
&lt;th&gt;Passport (both tags)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;none&lt;/td&gt;
&lt;td&gt;&lt;code&gt;***&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;NULL&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;NULL&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;analysts&lt;/td&gt;
&lt;td&gt;SHA-256 hash&lt;/td&gt;
&lt;td&gt;&lt;code&gt;NULL&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;NULL&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;analysts + pii_readers&lt;/td&gt;
&lt;td&gt;clear&lt;/td&gt;
&lt;td&gt;&lt;code&gt;NULL&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;NULL&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;analysts + pii_readers + sensitive_readers&lt;/td&gt;
&lt;td&gt;clear&lt;/td&gt;
&lt;td&gt;clear&lt;/td&gt;
&lt;td&gt;clear&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;pipeline&lt;/td&gt;
&lt;td&gt;clear&lt;/td&gt;
&lt;td&gt;clear&lt;/td&gt;
&lt;td&gt;clear&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;I repeated the matrix after &lt;a href="https://docs.databricks.com/aws/en/security/auth/rbac/switch-roles" rel="noopener noreferrer"&gt;switching to each group as a role&lt;/a&gt;, which makes Databricks run queries with that group's permissions only, and every result matched its policies. Analysts got hashes, &lt;code&gt;pii_readers&lt;/code&gt; got personal columns in clear, &lt;code&gt;sensitive_readers&lt;/code&gt; got &lt;code&gt;race&lt;/code&gt; in clear and personal columns as &lt;code&gt;***&lt;/code&gt;, and the pipeline got everything. No single reader role saw &lt;code&gt;PASSPORT&lt;/code&gt;, because that takes both groups.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Propagation is conservative.&lt;/strong&gt; &lt;code&gt;full_name&lt;/code&gt;, &lt;code&gt;ssn_last4&lt;/code&gt; and &lt;code&gt;ssn_hash&lt;/code&gt; all inherit the Personal tag, so a hash computed in the pipeline gets masked like the raw value. That is the right call: an unsalted SHA-256 of a 9-digit SSN can be reversed by hashing every possible value, which is why the &lt;a href="https://www.edpb.europa.eu/system/files/2025-01/edpb_guidelines_202501_pseudonymisation_en.pdf" rel="noopener noreferrer"&gt;EDPB&lt;/a&gt; treats such hashes as personal data. In gold, &lt;code&gt;race&lt;/code&gt; is a &lt;code&gt;GROUP BY&lt;/code&gt; dimension in an aggregate report, and it inherits Sensitive: without access, the report still has its 18 rows, but &lt;code&gt;race&lt;/code&gt; and &lt;code&gt;ethnicity&lt;/code&gt; read &lt;code&gt;NULL&lt;/code&gt; in every one, so only &lt;code&gt;gender&lt;/code&gt; is left to tell them apart. For analysts, the pseudonymized SSN was identical in bronze and silver, and a bronze-to-silver join on it returned all 1,163 rows.&lt;/p&gt;

&lt;p&gt;To release a derived column, change the policy (pseudonymize instead of redact). Do not remove the tag downstream, because classification is supposed to live in one place.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5hpayij0yrzky3gq430q.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5hpayij0yrzky3gq430q.png" alt="Tag propagation visual Example" width="800" height="540"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Problems I hit
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. A masked writer persists the mask.&lt;/strong&gt; This one cost data. A CTAS reads the source through the masks of whoever runs it. On the first silver/gold build, &lt;code&gt;ssn_hash&lt;/code&gt; had &lt;strong&gt;1 distinct value across 1,163 rows&lt;/strong&gt;, the hash of &lt;code&gt;***&lt;/code&gt;, and &lt;code&gt;gold.demographics&lt;/code&gt; had a single race, &lt;code&gt;***&lt;/code&gt;. No policy was involved anymore. The data itself was gone.&lt;/p&gt;

&lt;p&gt;Later I repeated it on purpose, after switching to the analyst group as a role. The CTAS stored SSN and names as SHA-256 and &lt;code&gt;race&lt;/code&gt; and &lt;code&gt;passport&lt;/code&gt; as &lt;code&gt;NULL&lt;/code&gt;, in all 1,163 rows, and an admin reading that copy gets the same hashes and nulls. The tags still propagated, so the copy stays governed, but the clear values are gone for everyone.&lt;/p&gt;

&lt;p&gt;So anyone without access who runs a CTAS cuts the new table off from the real values: its columns hold &lt;code&gt;***&lt;/code&gt;, &lt;code&gt;NULL&lt;/code&gt; or a SHA-256 string, never the original. The hash is the one case where the value can come back, by the same rule as &lt;code&gt;ssn_hash&lt;/code&gt; above. The pseudonymization mask does add a salt, but the salt is in the public repo, so hashing every possible SSN with it still reverses the copy. In production the salt belongs in a secret.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Fix:&lt;/em&gt; a &lt;code&gt;synthea_pipeline&lt;/code&gt; group in the &lt;code&gt;EXCEPT&lt;/code&gt; of every mask, and the pipeline running as a member of it. A job run as a pipeline-only user produced 1,163 distinct hashes, 6 races and 887 passports, with no &lt;code&gt;***&lt;/code&gt; written. A bundle job's &lt;code&gt;run_as&lt;/code&gt; takes a user or service principal, never a group, so membership is what makes the pipeline write clean data.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="k"&gt;SELECT&lt;/span&gt; &lt;span class="nb"&gt;count&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;DISTINCT&lt;/span&gt; &lt;span class="n"&gt;ssn_hash&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;distinct_hashes&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;count&lt;/span&gt;&lt;span class="cm"&gt;(*) AS rows
FROM synthea.silver.patients;   -- expect 1,163 / 1,163, not 1 / 1,163
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;2. &lt;code&gt;EXCEPT&lt;/code&gt; means OR, not AND.&lt;/strong&gt; &lt;code&gt;PASSPORT&lt;/code&gt; carries both tags, so only users in &lt;em&gt;both&lt;/em&gt; reader groups should see it. The obvious policy says &lt;code&gt;EXCEPT synthea_pii_readers, synthea_sensitive_readers&lt;/code&gt;, but &lt;code&gt;EXCEPT&lt;/code&gt; exempts anyone in &lt;em&gt;any&lt;/em&gt; listed group, so a user in &lt;code&gt;sensitive_readers&lt;/code&gt; alone would skip the mask and see passport numbers. &lt;code&gt;EXCEPT&lt;/code&gt; cannot say "in both groups", so the policy exempts only the pipeline, and the mask function checks both groups itself:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="k"&gt;CASE&lt;/span&gt; &lt;span class="k"&gt;WHEN&lt;/span&gt; &lt;span class="nf"&gt;is_account_group_member&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'synthea_pii_readers'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
      &lt;span class="k"&gt;AND&lt;/span&gt; &lt;span class="nf"&gt;is_account_group_member&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'synthea_sensitive_readers'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
     &lt;span class="k"&gt;THEN&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="k"&gt;ELSE&lt;/span&gt; &lt;span class="kc"&gt;NULL&lt;/span&gt; &lt;span class="k"&gt;END&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I caught this by reading the policy definitions, not through a test. The role test above confirms the fix: as &lt;code&gt;sensitive_readers&lt;/code&gt; alone, &lt;code&gt;PASSPORT&lt;/code&gt; reads &lt;code&gt;NULL&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Group membership changes are not instant.&lt;/strong&gt; After I left the reader groups in the UI, &lt;code&gt;is_account_group_member()&lt;/code&gt; kept returning true for about 2 minutes. A persona test in that window proves nothing, so I check effective membership in the same session before each run.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. Smaller ones.&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The governance job once recreated the policies while the medallion job was mid-build. Run governance first, or use one job with a dependency.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;DROP POLICY&lt;/code&gt; has no &lt;code&gt;IF EXISTS&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Free Edition has no account API (&lt;code&gt;databricks account groups list&lt;/code&gt; fails even for a workspace admin), so the groups were created in the UI. Its workspace also lacks &lt;a href="https://docs.databricks.com/aws/en/data-governance/unity-catalog/data-classification" rel="noopener noreferrer"&gt;Data Classification&lt;/a&gt;, the LLM-assisted scanner that would replace hand-tagging at scale.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What I did not test
&lt;/h2&gt;

&lt;p&gt;These come from the docs, not from the lab:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Declarative pipelines (DLT) and pipeline materialized views do not propagate tags.&lt;/li&gt;
&lt;li&gt;Until a tag arrives on a derived table, policies that reference it are not enforced there.&lt;/li&gt;
&lt;li&gt;Two policies that resolve to different masks for the same user and column make the query fail.&lt;/li&gt;
&lt;li&gt;A STRING mask such as &lt;code&gt;'***'&lt;/code&gt; on a &lt;code&gt;DATE&lt;/code&gt; or &lt;code&gt;INT&lt;/code&gt; column breaks reads.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Writing under every role.&lt;/strong&gt; Every role was tested for reads, but I ran a CTAS under one role only, the analysts, in Problem 1.&lt;/li&gt;
&lt;li&gt;Whether the &lt;code&gt;class.*&lt;/code&gt; tags from Data Classification propagate like custom governed tags.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Takeaways
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Turn on propagation for each governed tag first. Nothing else works without it.&lt;/li&gt;
&lt;li&gt;Keep every &lt;code&gt;SET TAGS&lt;/code&gt; in one file for the source layer, and make a missing downstream tag a failing test.&lt;/li&gt;
&lt;li&gt;Exempt the pipeline identity from every mask, and check distinct counts after each build. Masked users get &lt;code&gt;CREATE&lt;/code&gt; only in a sandbox schema.&lt;/li&gt;
&lt;li&gt;Make sure no user and column can resolve to two masks: disjoint tags or disjoint principals.&lt;/li&gt;
&lt;li&gt;Expect derived columns, hashes and aggregate dimensions to stay sensitive. Loosen them with a policy, not by removing tags.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Tag propagation is still in Beta, but it is one of the most useful governance features I have tested in Unity Catalog. It moves classification out of a spreadsheet and into the lineage, so "is this derived table protected?" gets the same answer as "is its source protected?", without anyone having to remember to ask. That matters more every year. The same IBM report found that one in four malicious breaches were AI-enabled, and phishing was the most common way in. An attack that goes through people ends with a valid login, and what that login can read is decided by access policies. When every copy inherits its policy, a phished analyst account gets hashes and &lt;code&gt;NULL&lt;/code&gt;s, not the one table somebody forgot to tag.&lt;/p&gt;

&lt;p&gt;The full lab, with the bundle, the SQL and the tests, is on GitHub: &lt;a href="https://github.com/ViniCarvalhoData/synthea_databricks" rel="noopener noreferrer"&gt;ViniCarvalhoData/synthea_databricks&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>databricks</category>
      <category>governance</category>
      <category>privacy</category>
      <category>dataengineering</category>
    </item>
    <item>
      <title>Build without limits - SDLC Briefing, #5</title>
      <dc:creator>Ricardo Sueiras</dc:creator>
      <pubDate>Mon, 09 Nov 2026 07:50:15 +0000</pubDate>
      <link>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-5-1hnp</link>
      <guid>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-5-1hnp</guid>
      <description>&lt;p&gt;&lt;em&gt;Hi! I am Ricardo Sueiras, leading SDLC transformation at Indicium AI. That means I get to  work with customers and help them understand how to use agentic AI to build software. New tools, practices and opinions turn up every week, and Build without Limits cuts through the noise. In each edition we put together a short, curated briefing on what's worth reading, watching and worth trying. You can skim it in five minutes and dive deeper wherever something catches your eye.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Top of Mind
&lt;/h2&gt;

&lt;p&gt;Top of mind this week is Developer Portals (sometimes referred to as IdP's, although as someone who has spent time building identity systems, I always get the hump that this TLA has been usurped!). I had several good discussions with customers, who are looking at leveraging their developer portals to include gold paths for agentic solutions. &lt;/p&gt;

&lt;p&gt;One of the surprising things that has come up in these conversations is how to rethink those same developer portals for a new kind of developer. Citizen Developer specifically, and how platform teams are now beginning to rethink what the design and user experience looks like for this new kind of user. Hannah Foxwell added to this discussion in &lt;a href="https://www.linkedin.com/posts/hannah-foxwell_a-beautifully-simple-illustration-of-the-share-7523723309385928705-CfP_/" rel="noopener noreferrer"&gt;her post on LinkedIn&lt;/a&gt; by adding that it was not just Citizen developer we needed to think of but agents more broadly. This makes sense to me, one place in which to manage and govern everything. I am folllowing this closely, and will share what I find.&lt;/p&gt;

&lt;h2&gt;
  
  
  Must reads this week
&lt;/h2&gt;

&lt;p&gt;These were my favorite posts this week.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.geekwire.com/2026/amazon-rewrites-its-software-engineering-playbook-for-an-era-when-ai-writes-the-code/" rel="noopener noreferrer"&gt;Amazon rewrites its software engineering playbook for an era when AI writes the code&lt;/a&gt; - took me by surprise last week, with Marc Brooker sharing some of the lessons Amazon has learned across their engineering teams and how this is changing how they approach development.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/adimango/ai-adoption-playbook" rel="noopener noreferrer"&gt;https://github.com/adimango/ai-adoption-playbook&lt;/a&gt; - provides an opinionated guide on how you might roll out AI across your organisation. I haven't tried it yet, and I have my reservations on how this might work as in my experience, how you roll out and enable an organisation for AI varies hugely and is based on lots of factors. That said, they have done a lot of work pulling together useful tools that will help you with the planning activities.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://dev.to/playfulprogramming/github-universe-2026-my-recap-from-san-francisco-23hd"&gt;Recap from GitHub universe&lt;/a&gt;- if you want a summary of the main things that went down at Github's annual tech conference, I found this post provided a good summary. I also listened to the &lt;a href="https://syntax.fm/show/1052/github-universe-keynote-recap" rel="noopener noreferrer"&gt;Syntax&lt;/a&gt; podcast as well. There have been lots of stories about Github's future as it tries to cope with the sheer scale of the impact of agentic engineering. &lt;a href="https://github.blog/engineering/architecture-optimization/inside-githubs-new-git-storage-architecture/" rel="noopener noreferrer"&gt;Inside GitHub’s new Git storage architecture&lt;/a&gt; looks at how they are innovating their storage architecture to cope.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://pearpages.com/blog/2026/11/03/scaling-software-built-with-ai-where-the-real-bottlenecks-are" rel="noopener noreferrer"&gt;Scaling software built with AI: where the real bottlenecks are&lt;/a&gt; - a long read that covers a lot of ground, looking at the current state of agentic development. Whilst there is nothing new or groundbreaking in this post, its ways its all brought together makes it a good read.&lt;/p&gt;

&lt;h2&gt;
  
  
  Watch this
&lt;/h2&gt;

&lt;p&gt;Last week I listened to this episode of the Engineering Enablement podcast from the folks at DX, where Roblox's Andrew Swerdlow dived into how they approach code review across their engineering teams and how they measure the impact of agentic engineering. This one is packed with some great approaches that I will be adding to my toolbox.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/j3YuAfNCZGk" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  Tools to try out
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Third-party tools links are provided as-is. They belong to their owners, follow their own licenses, and are used at your own risk.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/shanselman/sandbox-mcp" rel="noopener noreferrer"&gt;https://github.com/shanselman/sandbox-mcp&lt;/a&gt; - this was news to me, that Windows had a capability for creating sandbox environments that you can use to launch your agents in. None other than Microsofts Scott Hanselman has put together an MCP that gives your agent everything you need to get started. Many of the developers I work with use Windows, so this is a great tip.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/govijr/terminal-mac" rel="noopener noreferrer"&gt;https://github.com/govijr/terminal-mac&lt;/a&gt; - if you like the Windows sandbox tool above, then this tool provides a separate desktop for your computer use agents. The guest is a separate Mac: it has its own apps, files, accounts and permissions. Nice detailed docs, and this tool already has 2.5K stars.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/richardedens/crissp" rel="noopener noreferrer"&gt;https://github.com/richardedens/crissp&lt;/a&gt; - is another AI SLDC framework that has three layers (agent colleagues that build, guards that make sure it is built correctly , and then product which defines what gets built). Not had time to try it out, but I like to check the repos out and get inspired or borrow ideas from them.&lt;/p&gt;

&lt;h2&gt;
  
  
  From the field
&lt;/h2&gt;

&lt;p&gt;Developer experience is increasingly surfacing in the work I do with customers, which should perhaps be no surprise for folk who are working at helping organisations adopt agentic engineering. Recently it has come up in the topic of quality, and how a good developer experience correlates to higher quality software. We knew this of course, and Accelerate and DORA provided the data to back this up, but as you start to think about your own agentic engineering roll outs and SDLC modernisation, make sure you put developer experience at the centre. &lt;/p&gt;

&lt;p&gt;One of the ways I see developer experience manifest at a practical level is how they are setup for agentic development. When I speak with developers, I am pretty nosey and like to see their setup (and I also find that developers mostley love to share). When I saw &lt;a href="https://news.ycombinator.com/item?id=50366117" rel="noopener noreferrer"&gt;this thread&lt;/a&gt; come up on Hacker News of developers sharing their setup, I spent a lot of time and went down lots of rabbit holes to find out just how developers were optimising for agentic development. When I last checked it, just over 600 responses.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;If you enjoyed this, then remember to subscribe to the IndiciumAI blog so that you can keep up to date with future editions of this newsletter, as well as other great content that technologists at IndiciumAI will publish.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>claude</category>
      <category>ai</category>
      <category>developer</category>
    </item>
    <item>
      <title>Reviewing PRs in an Agentic Era</title>
      <dc:creator>Millie Wan Marriott</dc:creator>
      <pubDate>Mon, 02 Nov 2026 12:03:30 +0000</pubDate>
      <link>https://dev.to/indiciumai/reviewing-prs-in-an-agentic-era-24gh</link>
      <guid>https://dev.to/indiciumai/reviewing-prs-in-an-agentic-era-24gh</guid>
      <description>&lt;h2&gt;
  
  
  Code Review When Agents Do the First Pass: What Still Matters for Humans
&lt;/h2&gt;

&lt;p&gt;A couple of weeks ago, Anthropic published their model for internal code review: several agents review each PR, a second group votes on the issues they find, before it gets to human evaluation. The risk level assigned determines how many human reviewers (if any) are needed.&lt;/p&gt;

&lt;p&gt;That model is compelling and is the future for many engineering teams, but it assumes a lot of tokens and a full agentic setup. Many engineering teams don’t have that budget, and many don’t need the full machinery right now, but, even so, most teams are using some form of AI in code review. So, if agents are already reviewing the PR, what changes for us as human reviewers?&lt;/p&gt;

&lt;h2&gt;
  
  
  What code review is for
&lt;/h2&gt;

&lt;p&gt;Anthropic noted the two jobs of code review:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Find and fix issues before they ship.&lt;/li&gt;
&lt;li&gt;Build shared context and codebase understanding across the team.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Agents are increasingly good at the first but the second is where the human role needs rethinking.&lt;/p&gt;

&lt;h2&gt;
  
  
  Human Role
&lt;/h2&gt;

&lt;p&gt;Anthropic’s article lists the decisions that machines handle poorly and that humans should keep:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Should we build this at all?&lt;/strong&gt; Direction, taste, and scope of the changes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Risky code.&lt;/strong&gt; Anything where a mistake is expensive.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Architecture that sets a pattern.&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reading the evidence.&lt;/strong&gt; Test outputs, screenshots, and the reviewer’s findings.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Owning the outcome.&lt;/strong&gt; Accountability for every change that ships&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What’s changed
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Accountability is thinner on the approver side.&lt;/strong&gt; The author still owns the change. But when an agent has already caught most mechanical mistakes, a human approver can drift into rubber-stamping. That’s somewhat okay, since AI is good at catching errors. It’s a problem for the things AI is less good at. As approvers, we still need to take accountability for the code that’s being merged - it’s just that we should focus less on catching bugs and more on whether the code is good taste.&lt;/p&gt;

&lt;p&gt;Sean Goedecke describes engineering taste as &lt;strong&gt;‘composed of the set of engineering values you find most important’&lt;/strong&gt;. One project prioritises scalability over readability; another wants simple, well documented code. Of course, in a well setup project, our AI tools should be equipped to write code according to our taste - it should know for example whether to favour detailed or simple docstrings. In practice, it doesn’t always hold. Agents don’t always reliably code to your taste - this is where human review comes in.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Experienced engineers carry a mental map of the codebase.&lt;/strong&gt; When they review a change, they know what to check based on that map. Agents don’t have it by default, but you can give it to them. Good context practices help here: &lt;code&gt;CLAUDE.md&lt;/code&gt; files for project conventions, and &lt;code&gt;review.md&lt;/code&gt; files that spell out what a reviewer should look for in this codebase. You might add something like the below into your files.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;&lt;span class="gh"&gt;# CLAUDE.md  &lt;/span&gt;
&lt;span class="gu"&gt;## Code taste&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Names say what a thing &lt;span class="ge"&gt;*is*&lt;/span&gt; or &lt;span class="ge"&gt;*does*&lt;/span&gt;, not how it's implemented.
  &lt;span class="sb"&gt;`unpaidInvoices`&lt;/span&gt;, not &lt;span class="sb"&gt;`filteredList`&lt;/span&gt;.
&lt;span class="p"&gt;-&lt;/span&gt; Prefer boring, explicit code over abstractions. Three similar blocks
  are fine; extract only when a fourth appears or the duplication has
  already caused a bug.
&lt;span class="p"&gt;-&lt;/span&gt; Functions do one thing. If you need "and" to describe it, split it.
&lt;span class="p"&gt;-&lt;/span&gt; Handle errors where you can do something useful about them. Otherwise
  let them propagate with context. Never swallow an exception silently.
&lt;span class="p"&gt;-&lt;/span&gt; Comments explain &lt;span class="ge"&gt;*why*&lt;/span&gt;, not &lt;span class="ge"&gt;*what*&lt;/span&gt;. If the what needs explaining,
  rewrite the code.
&lt;span class="p"&gt;-&lt;/span&gt; Delete dead code; don't comment it out. Git remembers.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;&lt;span class="gh"&gt;# review.md&lt;/span&gt;

Review for correctness and risk first, style last. Linters handle formatting;
don't comment on it.

&lt;span class="gu"&gt;## How to write feedback &lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Lead with blocking issues, clearly labelled &lt;span class="gs"&gt;**[blocking]**&lt;/span&gt;.
  Mark everything else &lt;span class="gs"&gt;**[nit]**&lt;/span&gt; or &lt;span class="gs"&gt;**[question]**&lt;/span&gt;.
&lt;span class="p"&gt;-&lt;/span&gt; Say &lt;span class="ge"&gt;*why*&lt;/span&gt; something is a problem and suggest a fix where possible.
&lt;span class="p"&gt;-&lt;/span&gt; If the PR is fine, say so briefly. Don't invent feedback to look thorough.
&lt;span class="p"&gt;-&lt;/span&gt; Do not approve if you couldn't verify something important; say what
  you couldn't check.

&lt;span class="gu"&gt;## 1. Does it do what it claims?&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Read the PR description, then check the diff actually delivers it,
  and nothing else.
&lt;span class="p"&gt;-&lt;/span&gt; Walk the unhappy paths: empty input, nulls, timeouts, partial failure,
  retries, concurrent requests.

&lt;span class="gu"&gt;## 2. What could break that isn't in the diff?&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; xxx

&lt;span class="gu"&gt;## 3. Security and data&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; xxx

&lt;span class="gu"&gt;## 4. Operability &lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; xxx 

&lt;span class="gu"&gt;## 5. Tests  &lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; xxx
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;The review itself now needs review.&lt;/strong&gt; If agents are doing the first pass, their output needs measuring. Run evals on agentic reviews, check where they miss things your team cares about, and update the context files accordingly. The mental map improves over time only if you maintain it.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical starting point
&lt;/h2&gt;

&lt;p&gt;For teams without a large agentic review budget, a lighter setup might look like this:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Keep human review for risky paths (big changes, core parts of the codebase, code that is susceptible to breaking changes) and changes that set patterns.&lt;/li&gt;
&lt;li&gt;Write &lt;code&gt;CLAUDE.md&lt;/code&gt; and &lt;code&gt;review.md&lt;/code&gt; files that capture your taste.&lt;/li&gt;
&lt;li&gt;Track the misses: when a human catches something the agent didn’t, record it and feed it back into the context files.&lt;/li&gt;
&lt;li&gt;Make the approver’s responsibility explicit, so “claude looked at it” never substitutes for owning the change.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;Agents change the mechanics of code review more than its purpose. The first job, catching issues, is increasingly automated. The second job, building shared understanding, depends on keeping the team’s taste and codebase knowledge written down where the agents can use it, and checked by humans who still own what ships.&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>softwareengineering</category>
      <category>codereview</category>
    </item>
    <item>
      <title>Build without limits - SDLC Briefing, #4</title>
      <dc:creator>Ricardo Sueiras</dc:creator>
      <pubDate>Mon, 02 Nov 2026 08:23:16 +0000</pubDate>
      <link>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-4-lnf</link>
      <guid>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-4-lnf</guid>
      <description>&lt;p&gt;&lt;em&gt;Hi! I am Ricardo Sueiras, leading SDLC transformation at Indicium AI. That means I get to  work with customers and help them understand how to use agentic AI to build software. New tools, practices and opinions turn up every week, and Build without Limits cuts through the noise. In each edition we put together a short, curated briefing on what's worth reading, watching and worth trying. You can skim it in five minutes and dive deeper wherever something catches your eye.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Top of Mind
&lt;/h2&gt;

&lt;p&gt;“Tell me how you measure me and I’ll tell you how I will behave.”&lt;br&gt;&lt;br&gt;
― &lt;strong&gt;Eliyahu M. Goldratt, Critical Chain&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Hat tip to my former colleague Ray Krueger for that gem. Measurement is top if mind, and keeps coming up in conversations. James Shore has put together some of the best thinking in this space, so check out his series &lt;a href="https://www.jamesshore.com/v2/blog/2026/assessing-ai-impact-notes-for-your-cfo" rel="noopener noreferrer"&gt;Assessing AI Impact: Notes for Your CFO&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  Must reads this week
&lt;/h2&gt;

&lt;p&gt;These were my favorite posts this week.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.dbreunig.com/2026/10/24/the-state-of-context-engineering.html" rel="noopener noreferrer"&gt;The State of Context Engineering&lt;/a&gt; is a blog post come speaker notes from Drew Breunig's session at AgentCon. It was an easy read and I learned a few new things. I have given similar talks in the past (check out my talk at Prompt Engineering Conference, &lt;a href="https://www.youtube.com/watch?v=RS16ie_Bjco" rel="noopener noreferrer"&gt;Tips and Tricks for better prompting&lt;/a&gt;)&lt;/p&gt;

&lt;p&gt;&lt;a href="https://concurrent.cd/notes/hello-concurrent-cd" rel="noopener noreferrer"&gt;Hello concurrent-cd&lt;/a&gt; is the new home that Patrick Debois has put together to share research, experiments, and findings on the confluence of people and agents.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://leaddev.com/reporting/whats-next-for-dora" rel="noopener noreferrer"&gt;What's next for DORA&lt;/a&gt; I was pretty shocked to find out that there are going to be no more independent studies on software engineering practices and productivity. If you care about developer experience, this is going to be a miss. However, the methodology and questions are there for anyone to see - who will step in and carry on the work?&lt;/p&gt;

&lt;p&gt;&lt;a href="https://codecapsule.com/2026/10/04/what-i-learned-building-an-ai-software-factory" rel="noopener noreferrer"&gt;What I Learned Building an AI Software Factory&lt;/a&gt; is a nice walk through of one persons journey and learnings in creating a software factory. Well worth a read.&lt;/p&gt;
&lt;h2&gt;
  
  
  Watch this
&lt;/h2&gt;

&lt;p&gt;I am still messing around with Claude Code mods, and love seeing what folks are up to. AICodeKing shared a few that look genuinely interesting. I know a few folk who always need to see the files being created during a Claude Code session, so like to run it within an editor. One of the mods shown here might just present a cool solution for those folk.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/OTfS65T70L8" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  Tools to try out
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Third-party tools links are provided as-is. They belong to their owners, follow their own licenses, and are used at your own risk.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/frontiercc/command-centre" rel="noopener noreferrer"&gt;command centre&lt;/a&gt; is an amazing tool from my colleague Lee James. It provides an easy way for you to quickly extract insights across your Claude Code deployment. From finding out and managing token spend, discovering use cases, to tracking compliance and usage habbits. Give it a try.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/IBazylchuk/paparats-mcp" rel="noopener noreferrer"&gt;paparats-mcp&lt;/a&gt; is a relly neat tool that gives Claude Code or any MCP client semantic code search across many repositories: by meaning, with who calls what, and what a change will touch. It runs on your machine or sandboxed in a container. Why might you want to try this out? This approach will help you consume way less tokens, and be much more responsive. The README of the project has some data on that so give it a go.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/spotify/portal-ai-plugins/tree/main/plugins/shunt" rel="noopener noreferrer"&gt;shunt&lt;/a&gt; is an interesting tool from the folks at Spotify that helps drastically reduce token used by implementing a technique that tries to intercept operations that consume large reads. I heard about it after reading the blog post, &lt;a href="https://engineering.atspotify.com/2026/9/portal-by-spotify-cut-my-claude-code-token-usage-by-90" rel="noopener noreferrer"&gt;Portal by Spotify cut my Claude Code token usage by 90%&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  From the field
&lt;/h2&gt;

&lt;p&gt;One of the best parts of the Forward Deployed Engineering job is that you get to see up close how engineers use agentic engineering tools like Claude Code. There is always stuff coming up that you can learn from, and  this week, &lt;a href="https://github.com/anthropics/claude-code/issues/86879" rel="noopener noreferrer"&gt;this issue&lt;/a&gt; surfaced up. TLDR; in your Claude Code sessions, a simple feature that helps you signpost where you currently are, can quickly consume tokens over time.&lt;/p&gt;

&lt;p&gt;What is interesting is that this issue has two dimensions. The first, the recap message you see during your sessions, is one that you can easily disable via /config (turning recap from the default of true, to false to disable it). All good, except that this doesn't fix the issue for subagents. The issue comments go on to show how you can work around this (effectively disabling the spawning of agents). This &lt;a href="https://gist.github.com/flamerix-ai/c3905705cc4205e5de3011fa2e74efce" rel="noopener noreferrer"&gt;gist&lt;/a&gt; provides a hacky solution which I would not implement myself, but am sharing as its interesting to dive deeper into this issue.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;If you enjoyed this, then remember to subscribe to the IndiciumAI blog so that you can keep up to date with future editions of this newsletter, as well as other great content that technologists at IndiciumAI will publish.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>developer</category>
    </item>
    <item>
      <title>Build without limits - SDLC Briefing, #3</title>
      <dc:creator>Ricardo Sueiras</dc:creator>
      <pubDate>Mon, 26 Oct 2026 06:58:58 +0000</pubDate>
      <link>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-3-6a9</link>
      <guid>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-3-6a9</guid>
      <description>&lt;p&gt;&lt;em&gt;Hi! I am Ricardo Sueiras, leading SDLC transformation at Indicium AI. That means I get to  work with customers and help them understand how to use agentic AI to build software. New tools, practices and opinions turn up every week, and Build without Limits cuts through the noise. In each edition we put together a short, curated briefing on what's worth reading, watching and worth trying. You can skim it in five minutes and dive deeper wherever something catches your eye.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Top of Mind
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.brokenrobot.xyz/blog/more-agents-same-mythical-month/" rel="noopener noreferrer"&gt;More Agents, Same Mythical Month&lt;/a&gt; is one of the more impactful posts I have read in recent months. It articulates beautifully patterns I have been seeing in the field, and that every engineer should read to understand more. The anecdotes and stories alone make this post worth reading, but the additional groups linked to have now been added to my blogroll.&lt;/p&gt;

&lt;h2&gt;
  
  
  Must reads this week
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://copyconstruct.medium.com/how-to-effectively-debug-when-you-no-longer-understand-the-code-bd3dcb2c5f7b" rel="noopener noreferrer"&gt;How to effectively debug when you no longer understand the code&lt;/a&gt; is a post that kept me glued to my screen (I tend to use my commute time as the perfect time to catch up on all these posts, especially long ones like this one). I have spent some time also looking at practical approaches to using agents to debug and troubleshoot, and there is a lot of good stuff in this one.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://hamel.dev/blog/posts/decision-model-evals/" rel="noopener noreferrer"&gt;How To Use Decision Models for Evals&lt;/a&gt; came just in time as I managed to get some Jev tokens and am currently experimenting with decider models. A good intro that provides a lot of insights on how to get the best of these.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://claude.dev/" rel="noopener noreferrer"&gt;claude.dev&lt;/a&gt; is the new home for all things Claude Code for developers. A simpler layout makes it easier to find the things you care about. &lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.anthropic.com/research/formal-verification" rel="noopener noreferrer"&gt;LLMs are making formal software verification feasible at a much larger scale&lt;/a&gt; shares Anthropic's pov on the rise and rise of formal software verification in software development. It certainly follows what I have seen whilst I was working at AWS, and is well worth reading.&lt;/p&gt;

&lt;h2&gt;
  
  
  Watch this
&lt;/h2&gt;

&lt;p&gt;There are several collections of Claude Code Skills and workflows that have gained developer attention over the last several months. You have probably heard of Matt Pocock, almost certainly read Addy Osmani's writings on agentic engineering, but perhaps are new to Lauren Tan's pstack. Rob Shocks provides an overview of these three approaches, and in coming videos will be doing a bake off to see how they compare when working on common workflows.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/sU9MW8Ycq2M" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  Tools to try out
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Third-party tools links are provided as-is. They belong to their owners, follow their own licenses, and are used at your own risk.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/Graphicle-AI/graphicle" rel="noopener noreferrer"&gt;https://github.com/Graphicle-AI/graphicle&lt;/a&gt; graphs are so hot right now, and so here is a new tool (written in Rust of course) that maps your repository into a code graph, remembers your project's docs, decisions and past agent sessions, and gives your coding agent cited excerpts from both. Its fast, provides options to help you manage token spend, and works natively with Claude Code.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/The-PR-Agent/pr-agent" rel="noopener noreferrer"&gt;https://github.com/The-PR-Agent/pr-agent&lt;/a&gt; is an agentic AI powered code review tool from the folks that brought you qodo. It provides a number of tools (/describe, /review, and /improve) that you can run within your CI workflows or in your CLI. &lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/saphan-ai/proven" rel="noopener noreferrer"&gt;https://github.com/saphan-ai/proven&lt;/a&gt; is another agentic AI tool to help you with your code reviews. Proven takes a slightly different approach. Proven will review pull requests: proposed changes to a codebase. Every problem it reports must come with evidence you can check yourself, such as a test you can run or a data query you can repeat. If it cannot show the evidence, it does not report the problem.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/gojko/lights-on-software-factory" rel="noopener noreferrer"&gt;https://github.com/gojko/lights-on-software-factory&lt;/a&gt; is a nice starting point for exploring software factories. There are a few of these kinds of repos, and one of the reasons I love open source is that the four freedoms always let me learn from what others have built.&lt;/p&gt;

&lt;h2&gt;
  
  
  From the field
&lt;/h2&gt;

&lt;p&gt;This week it has been all about code reviews. I have been working with customers who unlock some real code review pain points, and wanted to share some of the content that I have been referencing that we have seen make an impact.&lt;/p&gt;

&lt;p&gt;It is probably obvious, but needs stating -  the larger the diff, the more findings LLMs will report. Thinking how to scope down tasks so that the PRs will be smaller, will make PR reviews easier - both cognitively for the human reviewer, but also bring back less findings. Posts like &lt;a href="https://lethain.com/small-changes/" rel="noopener noreferrer"&gt;Speeding up code review with small-change&lt;/a&gt; provide some insights in how organisations are tackling this. &lt;a href="https://www.oreilly.com/radar/code-review-after-code-gets-cheap/" rel="noopener noreferrer"&gt;Code Review After Code Gets Cheap&lt;/a&gt; is another post that looks (at a high level) at some of the options you should be thinking of. I am experimenting with some of the tools that I have shared above (in addition to the tools that Claude Code provides), and will report back how I get on with these.&lt;/p&gt;

&lt;p&gt;As a side note, it can be confusing initially to know what the native review capabilities that existing within Claude Code. This is what I ended up with, and (I think) covers the different native capabilities for Code Review within Claude Code (as well as where your own or third party ones plugin).&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Managed Code Review - run in GitHub, managed by Anthropic (docs dive into this &lt;a href="https://code.claude.com/docs/en/code-review" rel="noopener noreferrer"&gt;here&lt;/a&gt;)&lt;/li&gt;
&lt;li&gt;Local Code Review - run in your Claude Code session using /code-review&lt;/li&gt;
&lt;li&gt;GitHub Actions Code Review - run code reviews within your GitHub/GitLab actions, as a CI process (Claude in headless mode)&lt;/li&gt;
&lt;li&gt;Your own Review - implement your own Skills in your local sessions&lt;/li&gt;
&lt;li&gt;3P Code Review - a number of third party Code Review services (similar to Managed Code Review) are available: Coderabbit, Quodo, etc&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You can compare options &lt;a href="https://code.claude.com/docs/en/code-review#compare-ways-to-get-a-review" rel="noopener noreferrer"&gt;here&lt;/a&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;If you enjoyed this, then remember to subscribe to the IndiciumAI blog so that you can keep up to date with future editions of this newsletter, as well as other great content that technologists at IndiciumAI will publish.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>developers</category>
    </item>
    <item>
      <title>Langchain Interrupt26 - London: Why Evals and Traceability Matter More Than Your Agent Framework</title>
      <dc:creator>Gonçalo Lourenço</dc:creator>
      <pubDate>Tue, 20 Oct 2026 13:25:07 +0000</pubDate>
      <link>https://dev.to/indiciumai/langchain-interrupt26-london-why-evals-and-traceability-matter-more-than-your-agent-framework-2ce</link>
      <guid>https://dev.to/indiciumai/langchain-interrupt26-london-why-evals-and-traceability-matter-more-than-your-agent-framework-2ce</guid>
      <description>&lt;p&gt;&lt;em&gt;By Bruno Alho and Gonçalo Lourenço&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Seven of us went to LangChain's conference. We came back talking about evals.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;On Tuesday, we spent the day at &lt;a href="https://interrupt.langchain.com/" rel="noopener noreferrer"&gt;Interrupt&lt;/a&gt;, LangChain's conference on AI agents.&lt;/p&gt;

&lt;p&gt;We work as FDEs at Indicium AI, a global, AI-native data and AI consultancy, where we help clients build and ship AI agents. So naturally we went in curious about what was new, and came out thinking mostly about what it takes to put agents in production.&lt;/p&gt;

&lt;p&gt;There were product announcements, and we'll cover those first. But talk after talk kept circling back to the same three topics: evals, traceability and governance. Spoiler: none of them depend on which framework you pick.&lt;/p&gt;

&lt;h2&gt;
  
  
  What LangChain Announced
&lt;/h2&gt;

&lt;p&gt;Most of the product news was about LangSmith, LangChain's platform for observing and evaluating LLM applications. Two announcements stood out to us.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agents can now run inside LangSmith.&lt;/strong&gt; Using Deep Agents, LangChain's newest package, you can build, run and monitor an agent in one place. Fewer moving parts between "it works on my laptop" and "it's live" is always welcome.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Bring Your Own Cloud (BYOC).&lt;/strong&gt; Until now you had two options: self-host LangSmith, or use LangChain's cloud. BYOC adds a third, where the platform runs in your own cloud account. If you've ever sat through a data residency conversation with a client's security team, you'll know why this matters.&lt;/p&gt;

&lt;p&gt;It was a vendor conference, so yes, there was a healthy amount of selling the LangChain stack. But the products weren't what we were discussing on the way home.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Framework Is the Easy Choice
&lt;/h2&gt;

&lt;p&gt;The conversation has moved on from "can we build an agent?" to "can we trust it in production, and prove it?". That second question looks the same whether you use LangGraph, another framework or your own code. Every team runs into three problems:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Evals:&lt;/strong&gt; how do we know the agent does the right thing, before and after release?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Traceability:&lt;/strong&gt; when it gets something wrong, can we see why?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Governance:&lt;/strong&gt; can we show a client, an auditor or a regulator what the agent did, and who signed off?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Good tooling makes all three easier. Building the habit is still on us.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fug38ooat3qgxb5u7zdyd.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fug38ooat3qgxb5u7zdyd.png" alt=" " width="799" height="471"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The agent can be built with anything. What makes it production-ready is what sits around it: a trace of every step, feeding both evals and governance.&lt;/p&gt;

&lt;h2&gt;
  
  
  Evals Are Your Agent's Test Suite
&lt;/h2&gt;

&lt;p&gt;Nobody merges code without tests (well, nobody admits to it). Agents deserve the same treatment, with one twist: LLM outputs vary from run to run, so a single check before release isn't enough. The talks described evals at three stages:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Offline evals&lt;/strong&gt; run before every release against a curated dataset of inputs and expected behaviour. Change a prompt, a model or a tool, and they tell you what broke.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Online evals&lt;/strong&gt; score real production traffic continuously, using LLM-as-judge, simple heuristics and user feedback. They catch the drift and edge cases your dataset never imagined.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Human review&lt;/strong&gt; sends the tricky cases to domain experts. Their labels go back into the offline dataset, so every failure becomes a future test.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That feedback loop is the part teams most often skip, and it's the part that makes the agent actually improve.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7eoot15btws45s2zln2y.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7eoot15btws45s2zln2y.png" alt=" " width="800" height="292"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Offline evals gate each release, online evals watch production, and human review turns the hard cases into new entries in the dataset.&lt;/p&gt;

&lt;p&gt;The announcement that fit this theme best was &lt;strong&gt;Red Teaming in LangSmith Engine&lt;/strong&gt;. It reads your agent's traces and code to learn what the agent is for, then probes it for failures that haven't happened in production yet, like hallucinations or ignored system-prompt rules. Each confirmed issue arrives with a root cause, a suggested fix and test cases for your eval dataset. In other words, it writes the tests you forgot to. It's still in private beta and only for agents on LangSmith Deployment, but it's the right direction.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmyvwdjhbwjshfa3g2ilr.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmyvwdjhbwjshfa3g2ilr.png" alt=" " width="800" height="381"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;A probe only becomes an issue once the failure is confirmed, so you aren't flooded with false alarms. Each issue then splits two ways: a fix that's tested before you see it, and new test cases that go straight into your eval dataset.&lt;/p&gt;

&lt;h2&gt;
  
  
  Traceability: Show Your Working
&lt;/h2&gt;

&lt;p&gt;Remember maths teachers asking you to show your working? Agents need the same rule. A final answer is the end of a chain of retrievals, tool calls and LLM calls. Log only the answer and a wrong one is a mystery. Trace every step and it becomes a bug with an address.&lt;/p&gt;

&lt;p&gt;A useful trace records, for every run:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;each LLM call, with its inputs, outputs, latency and cost&lt;/li&gt;
&lt;li&gt;each tool call and what came back&lt;/li&gt;
&lt;li&gt;each retrieval and the documents it surfaced&lt;/li&gt;
&lt;li&gt;the decision the agent took at each branch&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;With that in place, you can follow a bad answer back to its cause, whether that's the retriever pulling the wrong document or a tool returning stale data. Fix it, then add the case to your eval set so it can't sneak back in.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flc9xnndnvbjcaai1xwsy.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flc9xnndnvbjcaai1xwsy.png" alt=" " width="800" height="292"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;With only the final answer logged, the bad retrieval is invisible. With every step traced, it is the first thing you see.&lt;/p&gt;

&lt;h2&gt;
  
  
  Governance: Keeping the Receipts
&lt;/h2&gt;

&lt;p&gt;This is where evals and traceability pay off for the business. The traces you collect for debugging double as an audit trail: a record of what the agent saw, what it did and why.&lt;/p&gt;

&lt;p&gt;The other half is keeping people in control where it counts. Human-in-the-loop checkpoints let an agent pause before a high-impact action (sending an email, changing a record, approving a payment) and wait for someone to confirm.&lt;/p&gt;

&lt;p&gt;For clients in regulated industries, this is often what decides whether a pilot ever makes it to production.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5clmrx8lxtkkla7x8m44.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5clmrx8lxtkkla7x8m44.png" alt=" " width="799" height="302"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Low-impact actions run straight away. High-impact ones wait for a person. Either way, the action ends up in the audit trail.&lt;/p&gt;

&lt;h2&gt;
  
  
  What We're Taking Back to Our Projects
&lt;/h2&gt;

&lt;p&gt;At Indicium AI we put agents in front of clients, so these practices belong in the delivery from day one. Here's the checklist we left Interrupt with:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Start an eval dataset on day one, even a small one, and grow it with every failure you find&lt;/li&gt;
&lt;li&gt;Run offline evals on every change to a prompt, model or tool&lt;/li&gt;
&lt;li&gt;Score production traffic continuously, not only at launch&lt;/li&gt;
&lt;li&gt;Trace every step of every run, not just the final answer&lt;/li&gt;
&lt;li&gt;Add human approval before any action that's hard to undo&lt;/li&gt;
&lt;li&gt;Agree with the client up front what "good" looks like and how you'll measure it&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of this needs a particular vendor. It needs the discipline to treat agents like any other production software.&lt;/p&gt;

&lt;h2&gt;
  
  
  What We'd Love to See at Interrupt 2027
&lt;/h2&gt;

&lt;p&gt;We'll be back next year. Two wishes for the organisers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;More "what broke, and how we fixed it" stories.&lt;/strong&gt; Next year, we'd love to swap some of the "what went right" stories for "what went wrong, and how we fixed it" ones. Those are the talks we learn the most from.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;More room in the eval workshops.&lt;/strong&gt; The hands-on eval workshops were the right idea, but they filled up so fast that we couldn't get into any. Bigger rooms, more sessions or a waitlist would let more people actually attend.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Interrupt confirmed something we already suspected: the agents that reach production are the ones people can test, explain and audit. Frameworks will keep coming and going. Those three habits will stay.&lt;/p&gt;

&lt;p&gt;If we had to put what we learned in one sentence: &lt;strong&gt;choose your framework in an afternoon, then spend the rest of the project on evals and traces.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Working on agents yourself? We'd love to compare notes on evals or traceability in the comments.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Written by Bruno Alho, Senior FDE, and Gonçalo Lourenço, Senior FDE, at Indicium AI. Follow us on LinkedIn: &lt;a href="https://www.linkedin.com/in/bruno-alho" rel="noopener noreferrer"&gt;Bruno Alho&lt;/a&gt; · &lt;a href="https://www.linkedin.com/in/goncalo-rodrigues-lourenco/" rel="noopener noreferrer"&gt;Gonçalo Lourenço&lt;/a&gt;. All views are our own.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;If you enjoyed this, subscribe to the Indicium AI blog to keep up with what our technologists publish next.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>langchain</category>
      <category>agents</category>
      <category>llmops</category>
    </item>
    <item>
      <title>An understanding of my world: a knowledge graph over my Obsidian notes</title>
      <dc:creator>GianPiero Bresolin</dc:creator>
      <pubDate>Mon, 19 Oct 2026 14:05:45 +0000</pubDate>
      <link>https://dev.to/indiciumai/an-understanding-of-my-world-a-knowledge-graph-over-my-obsidian-notes-c7e</link>
      <guid>https://dev.to/indiciumai/an-understanding-of-my-world-a-knowledge-graph-over-my-obsidian-notes-c7e</guid>
      <description>&lt;h2&gt;
  
  
  I have too many notes
&lt;/h2&gt;

&lt;p&gt;In my job I take a lot of notes. I mean a lot of notes. I attend a lot of meetings, and client conversations, catch-ups with colleagues, workshops and the research I pull together for a pursuit all get written down. My vault holds more than 900 markdown files now, organized into a structure of my own.&lt;/p&gt;

&lt;p&gt;The problem is what happens as that folder grows. There are too many notes to consume. The structure still makes sense, but it can't tell me what I actually want to know, which is usually something about people, clients and the commitments between them.&lt;/p&gt;

&lt;p&gt;Take a question like "who owns the Northwind data contract?" The answer is in there, in a sentence about Dana Whitfield in a quarterly review note. A search will find the note, along with every other note that mentions Northwind. It won't give me the owner.&lt;/p&gt;

&lt;h2&gt;
  
  
  My vision
&lt;/h2&gt;

&lt;p&gt;So I wanted a way of managing and storing that data that lets me query it in the right way. I want to ask a question in my own words and get the answer, along with the note it came from. That means storing my notes in a way that understands the people, clients and relationships in them.&lt;/p&gt;

&lt;h2&gt;
  
  
  My solution
&lt;/h2&gt;

&lt;p&gt;Building it turned out to be the manageable part. In my experience the real problem is maintaining the data over time, and that problem shapes every choice in the rest of this post. The system is a consistent folder structure, markdown notes with OKF metadata, a Graphiti graph with my own ontology, a daily Cowork task that keeps it current, and an MCP server that puts it into my daily work.&lt;/p&gt;

&lt;h2&gt;
  
  
  I picked a structure and stuck to it
&lt;/h2&gt;

&lt;p&gt;I'll show you mine as an example.&lt;/p&gt;

&lt;p&gt;My vault has a "Clients" folder, with a folder for each client. Each one holds that client's information and its own people folder, so I can see the people who belong to that client. There's a top-level People folder as well, and folders that describe our go-to-market work and specific teams. Roughly, it looks like this (Northwind is an invented client):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Obsidian Vault/
  Clients/
    northwind/
      Northwind.md
      2026-09-14 quarterly review.md
      people/
        Dana Whitfield/
          Dana Whitfield.md
  People/
  Blog Posts/
  Strategy/
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You're going to query this knowledge store in your own language. When you talk to Claude, you'll use your own references and the aliases you use for people and clients, so the structure has to make sense to you, and mine won't necessarily.&lt;/p&gt;

&lt;p&gt;Whatever you choose, follow it consistently, because that consistency is what the rest of this system depends on.&lt;/p&gt;

&lt;h2&gt;
  
  
  I built on markdown
&lt;/h2&gt;

&lt;p&gt;Markdown is the foundation of all of this.&lt;/p&gt;

&lt;p&gt;People who work with LLMs regularly are comfortable with it already. For anyone who isn't, it's a very simple plain-text format, and it's one LLMs really like to work with. Any tool that reads text can read it, so the notes aren't tied to one app.&lt;/p&gt;

&lt;p&gt;I write and read mine in an Obsidian vault. It's a good place to do that, and the wikilinks it uses to connect notes come back later in this story.&lt;/p&gt;

&lt;h2&gt;
  
  
  OKF FTW: I gave every note metadata
&lt;/h2&gt;

&lt;p&gt;So now I have all these markdown files, which is great. What I don't have is a real sense of the state of each one. Nothing has validated it, and there isn't enough metadata around it to build up a graph from.&lt;/p&gt;

&lt;p&gt;That's where the Open Knowledge Format comes in. OKF is published by Google Cloud (&lt;a href="https://github.com/GoogleCloudPlatform/open-knowledge-format" rel="noopener noreferrer"&gt;spec&lt;/a&gt;), and I went with it because it's lightweight. All it asks for is frontmatter: a set of keys and values at the top of the note. It's also extensible, so I can layer on new keys and values over time as I work out what I need, and that has been really helpful. Beyond that, it has a lot going for it because it comes from Google, which has the influence to help something like this gain popularity. And I like the idea of frontmatter as a metadata store. It's open-ended enough that it doesn't get in the way of how I already write.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="nn"&gt;---&lt;/span&gt;
&lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Meeting Notes&lt;/span&gt;
&lt;span class="na"&gt;title&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Northwind&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;quarterly&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;review"&lt;/span&gt;
&lt;span class="na"&gt;description&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Migration&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;scope,&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;timeline&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;pressure,&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;and&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;who&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;owns&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;the&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;data&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;contract."&lt;/span&gt;
&lt;span class="na"&gt;tags&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="nv"&gt;meeting&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;northwind&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;migration&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
&lt;span class="na"&gt;generated&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;by&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;claude/haiku-4-5&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;at&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;2026-09-14T11&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;&lt;span class="nv"&gt;10&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;&lt;span class="nv"&gt;37Z&lt;/span&gt; &lt;span class="pi"&gt;}&lt;/span&gt;
&lt;span class="nn"&gt;---&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Now each note carries metadata about itself: what kind of thing it is, a title, a one-line description, some tags, and a record of what produced it. That metadata could really be anything that makes sense of the document, and you can add whatever properties make sense for your organization.&lt;/p&gt;

&lt;p&gt;Say you want to mark when a document should be considered out of date. Add a key like &lt;code&gt;expires_after&lt;/code&gt; and put a date there. An LLM can read that key and change how it treats the note, as long as you tell it what the key means, so the metadata isn't arbitrary. A deterministic script can act on the same key, and so can anything else that reads frontmatter.&lt;/p&gt;

&lt;p&gt;That's what OKF gives me: a lightweight structure I can tie other actions to. A markdown file can feel very unstructured, and OKF brings structure to it without making me rewrite the document to follow some convention. The document can be whatever it wants to be. The metadata carries the information that programmatic solutions need, whether that's an LLM taking a particular action or a script that runs when it sees a particular value. It opens up a whole range of possibilities for how I organize my data.&lt;/p&gt;

&lt;p&gt;OKF's own design goals fit this well. Google's argument for it is that the context agents need should live in an open format of its own, somewhere other than a proprietary service or a pile of unstructured text. It's also deliberately minimally opinionated. &lt;code&gt;type&lt;/code&gt; is the only field that's always required, every other field is opt-in, and custom keys are preserved. That last part is what makes the expiry example work. (OKF v0.2 does define a &lt;code&gt;stale_after&lt;/code&gt; field for exactly that case, but the same holds for any key you invent.)&lt;/p&gt;

&lt;p&gt;Frontmatter also changes how much of a note anything has to read. A script can pull one property, such as the type or a date, without touching the body, and the same holds for an agent. Most of the time an agent only needs to decide whether a note is relevant, and the title, description and tags are enough for that.&lt;/p&gt;

&lt;p&gt;An agent won't stop at the frontmatter on its own, though. Left alone, it usually reads the whole file. The simplest fix is an instruction in its standing context: check the frontmatter first, and open the body only for the notes that look relevant. A skill or a tool goes further, because it can parse the frontmatter and hand the agent only those properties, so the body never reaches it unless it asks. In my vault, the sweep also rebuilds an index for each top-level folder, with one line per note built from its title and description, so an agent can scan a folder's index before it opens anything.&lt;/p&gt;

&lt;h3&gt;
  
  
  How I create the metadata
&lt;/h3&gt;

&lt;p&gt;Metadata only helps if every note has it, so keeping the vault in shape is a job for a script. Mine runs as a sweep, in a fixed order. It waits for the vault to go quiet, checks each note, fills in missing metadata, repairs what it can mechanically, links the names it already knows, rebuilds the indexes, scans for secrets and commits. The one step that needs a model is classification, where a model reads a new note and writes its type, title, description and tags. Everything else is plain code, and I'd keep it that way, because a deterministic job like string comparison belongs somewhere that gives the same answer every time.&lt;/p&gt;

&lt;p&gt;Keep the list of types small, too. My approved list has about thirty values, and the classifier only chooses from eight of them. Give a model an open list and it invents a plausible new type for any note that doesn't fit, and no query knows that type exists. A note that doesn't fit gets flagged for me to look at instead.&lt;/p&gt;

&lt;h2&gt;
  
  
  My notes are about relationships
&lt;/h2&gt;

&lt;p&gt;My notes have semantic structure, but mostly they're about relationships: between the notes themselves, and between the things they describe. Obsidian is built on that idea. It uses wikilinks to link documents together, which is how you build up your own knowledge graph inside Obsidian.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkwfr6fhvqzitwtyr1q1j.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkwfr6fhvqzitwtyr1q1j.png" alt="Obsidian graph view of my vault: a dense cluster of linked notes, with a few unconnected groups at the edges." width="800" height="876"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The Obsidian graph view does more than look nice. It shows the relationships between ideas and people, and it also shows the ideas that sit on their own. In the screenshot above, the small dots out towards the edges are parts of my knowledge that haven't been connected with the rest of the graph yet.&lt;/p&gt;

&lt;p&gt;It also shows where my attention goes. A dot grows as more notes link to it, so the people, entities and themes I talk about most stand out, and I can see who is really at the center of my world. That's useful for spotting gaps. An idea out on the edge may not be getting enough attention. And if there's someone who should be more prominent in my work and I can't see them in the graph, that's probably telling me there's an action I should take.&lt;/p&gt;

&lt;p&gt;The graph serves more than one purpose, and that's one of them. What I also needed was to query my data and pull out relationships, because for consultancy work that's where the value is. Everything I deal with has relationships to everything else: companies, clients, people, organizations, protocols, standards. In a graph, the kinds of relationships are commonly described with an ontology.&lt;/p&gt;

&lt;h2&gt;
  
  
  I use an ontology to bring meaning
&lt;/h2&gt;

&lt;p&gt;An ontology brings semantic understanding to your data. It says what kinds of things exist and how they can relate, so "Dana Whitfield is accountable for the Northwind data contract" means something a program can work with.&lt;/p&gt;

&lt;p&gt;So what I'm doing, ever so slowly, is building up a personalized knowledge domain. It comes in layers:&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart TB
    NOTES["Raw notes&amp;lt;br/&amp;gt;the content"]
    OKF["OKF frontmatter&amp;lt;br/&amp;gt;metadata and processing information"]
    ONT["Ontology and graph&amp;lt;br/&amp;gt;entities and the relationships between them"]
    LLM["An LLM asking questions&amp;lt;br/&amp;gt;of my notes"]

    NOTES --&amp;gt; OKF --&amp;gt; ONT --&amp;gt; LLM&lt;/code&gt;&lt;/pre&gt;



&lt;p&gt;The raw notes are the content. The OKF keys are metadata, plus whatever post-processing I want to record. Once I ingest those layers, the things they describe show up as entities, and the relationships between them as typed edges.&lt;/p&gt;

&lt;p&gt;This is where it becomes valuable. When the ontology is exposed to an LLM, the LLM can take my question, look at the entities and relationships it knows about, and work out where the relevant information is.&lt;/p&gt;

&lt;h3&gt;
  
  
  How a note becomes a fact
&lt;/h3&gt;

&lt;p&gt;Here's what that looks like for the Northwind question. From the quarterly review note, extraction pulls out two entities and the relation between them (illustrative):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Dana Whitfield (Person)  --ACCOUNTABLE_FOR--&amp;gt;  Northwind data contract (Contract)
  fact:   "Dana Whitfield owns the Northwind data contract and signs off changes to it."
  source: Clients/northwind/2026-09-14 quarterly review.md
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The relation carries a plain-language fact sentence and the path of the note it came from, so every answer the graph gives can point back to its source.&lt;/p&gt;

&lt;p&gt;This is also where the consistency from earlier pays off. An entity's identity comes from its type and its name, with no fuzzy matching. Two notes that both say &lt;code&gt;Northwind&lt;/code&gt; merge into one node, with no model call. A note that says &lt;code&gt;Northwind Trading&lt;/code&gt; instead creates a second node, and it stays separate until someone maps one name to the other. So the names you use consistently in your notes become the identity of things in your graph. A wikilink like &lt;code&gt;[[Dana Whitfield]]&lt;/code&gt; helps here too, because it gives extraction the exact spelling to use.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why I chose Graphiti
&lt;/h2&gt;

&lt;p&gt;I went with Graphiti for the graph because it's a widely used framework with a lot going for it. It lets me define my own entity and edge types in Python, and it brings the schema, typed edges and hybrid search with it.&lt;/p&gt;

&lt;p&gt;The bigger reason was speed. Building out a graph, and the database technology underneath it, can take a long time. Graphiti let me iterate quickly and get to the point where I could focus on the parts I cared about: the ontology, the data structure and the taxonomy I wanted to define.&lt;/p&gt;

&lt;p&gt;Graphiti needs a database underneath it, and I run FalkorDB in a single local container. It comes with a browser for looking at the graph, which is handy when you want to see what extraction actually produced. For embeddings, which the hybrid search depends on, I use a local model (&lt;code&gt;nomic-embed-text&lt;/code&gt;) through an endpoint Graphiti already speaks. The one model the graph pipeline calls out to is Claude Haiku 4.5, and that's there for cost: it's cheap enough to run over every changed note, every day.&lt;/p&gt;

&lt;h2&gt;
  
  
  How I keep the graph alive
&lt;/h2&gt;

&lt;p&gt;Once the ontology and taxonomy are in place, and there's somewhere to store them, the work isn't finished. My data keeps changing, so I need a daily process that brings in the new notes and notices when they describe a relationship the ontology doesn't have a name for yet.&lt;/p&gt;

&lt;p&gt;That's where Claude Cowork comes in.&lt;/p&gt;

&lt;p&gt;A scheduled task runs each day in Cowork and manages my data for me. It writes the OKF metadata for new notes, looks at the data, builds up a sense of the relationships in it, and proposes new relation types where nothing existing fits. It runs at 17:00 and only sends what changed since the last run to a model, so a quiet day sends nothing to a model.&lt;/p&gt;

&lt;p&gt;Getting those names right matters. The ontology is what brings sense to the data, and the name of a relationship is how the LLM understands what that relationship means. Say Dana Whitfield reports to the head of data at Northwind, but anything that goes wrong on the contract gets escalated to someone else entirely. Those are different relationships. If the graph gives them the same name, then when I ask who's accountable for the contract, the LLM can't tell them apart, and it may well hand me the wrong person.&lt;/p&gt;

&lt;p&gt;So a new relation name has to earn its place. Once the same name turns up in three different notes, it's promoted into the ontology automatically, and Claude Cowork can discover it.&lt;/p&gt;

&lt;p&gt;The same task can keep the graph clean as well as growing it, and this is where the OKF metadata from the beginning comes back in. Notes go out of date. Remember the &lt;code&gt;expires_after&lt;/code&gt; key? A scheduled task can read that date and treat an expired note differently, retire its facts from the graph, or flag it for me to review. The idea works for any property you define. Your metadata can decide what gets cleaned up, what gets removed from the graph because it's no longer relevant, and how the rest of the data is organized. That interplay between a lightweight metadata format and a task that runs every day is where a lot of the possibilities open up.&lt;/p&gt;

&lt;p&gt;I think this applies well beyond ontologies. Any document that tells a model how things currently stand will go out of date, and nothing in the document will tell the model so. That's the kind of problem OKF metadata like an expiry date is there to solve.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where I use it every day
&lt;/h2&gt;

&lt;p&gt;The last piece is an MCP server that exposes the knowledge graph. Because it's MCP, the graph isn't only available to Cowork. Any agent that can access a local MCP server can use it. I use it with Cowork, and that's where all the pieces, and all the work that came before, start to tie together.&lt;/p&gt;

&lt;p&gt;This is where the value actually comes alive. Without this step, it's fancy metadata on my notes. The wikilinks add something too, because they let me see my graph in Obsidian. But the real value, in my mind, is being able to integrate this into my daily work. In Cowork I can ask questions about my own notes and get answers that come from an understanding of my world, and connecting the graph through MCP opens up a whole host of possibilities beyond that.&lt;/p&gt;

&lt;h3&gt;
  
  
  My MCP server
&lt;/h3&gt;

&lt;p&gt;The server itself is small: one Python process that talks over stdio. It needs no API key, because search runs on the local embeddings and queries go straight to FalkorDB. It gives Claude seven read-only tools, and two of them show the idea well. &lt;code&gt;entity_profile&lt;/code&gt; returns a summary of what the graph knows about a named entity. &lt;code&gt;find_relations&lt;/code&gt; helps Claude work out which relationship fits a question when it doesn't know the relation name, and that's how the ontology becomes something Claude can discover.&lt;/p&gt;

&lt;p&gt;The server also carries instructions, which Claude reads when it connects. Mine tells it to check the graph before a Slack or web search when I ask about my own notes, and to name both sources when Slack and the graph disagree. That matters, because the graph only knows what my notes captured. If Claude filled a gap from the web, the answer would read as though it came from my notes, and I would repeat it with the same confidence.&lt;/p&gt;

&lt;h3&gt;
  
  
  What leaves my laptop
&lt;/h3&gt;

&lt;p&gt;Much of my work is in regulated environments, so I'd call this out. The graph, the database and the embeddings all stay on my laptop, but every model step in the graph pipeline sends note text to Claude Haiku 4.5, the scheduled task itself runs in Cowork, and answers go to the Claude app that asked for them. Make sure that's acceptable for what's in your notes before you point this at them. The server only runs on my laptop, so a web or phone session can use it only through the Claude desktop app on my laptop, while that app is running.&lt;/p&gt;

&lt;p&gt;Here's what Claude gets back when it profiles the contract &lt;em&gt;(illustrative)&lt;/em&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Northwind data contract (Contract)
  ACCOUNTABLE_FOR  &amp;lt;- Dana Whitfield
    "Dana Whitfield owns the Northwind data contract and signs off changes to it."
    source: obsidian://open?vault=Obsidian%20Vault&amp;amp;file=Clients/northwind/2026-09-14%20quarterly%20review
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;So, who owns the Northwind data contract? Dana Whitfield, according to the quarterly review on 14 September, and the answer comes back with a link to the note.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I'm building next
&lt;/h2&gt;

&lt;p&gt;I've also done a test run of Qwen 3 locally on Apple's MLX framework, using the 14B model quantized to 4-bit. The next step is to see whether a local model like that can take over the model steps. Today every model step sends note text to Claude Haiku 4.5. A local model would keep that text on the laptop, which matters for anyone whose notes come from regulated work.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>knowledgegraph</category>
      <category>claudecowork</category>
      <category>okf</category>
    </item>
    <item>
      <title>Build without limits - SDLC Briefing, #2</title>
      <dc:creator>Ricardo Sueiras</dc:creator>
      <pubDate>Mon, 19 Oct 2026 09:05:21 +0000</pubDate>
      <link>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-2-2c7p</link>
      <guid>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-2-2c7p</guid>
      <description>&lt;p&gt;&lt;em&gt;Hi! I am Ricardo Sueiras, leading SDLC transformation at Indicium AI. That means I get to  work with customers and help them understand how to use agentic AI to build software. New tools, practices and opinions turn up every week, and Build without Limits cuts through the noise. In each edition we put together a short, curated briefing on what's worth reading, watching and worth trying. You can skim it in five minutes and dive deeper wherever something catches your eye.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Top of Mind
&lt;/h2&gt;

&lt;p&gt;How to approach reviewing code has been top of mind this week, and came up in conversations during the &lt;a href="https://www.linkedin.com/feed/update/urn:li:ugcPost:7516528300643553280/" rel="noopener noreferrer"&gt;Applied AI Symposium that Indicium AI held in London this week&lt;/a&gt;. My timeline also had some interesting posts on this topic. First up was Spotify sharing how they tackle this in their post &lt;a href="https://engineering.atspotify.com/2026/9/ai-changed-how-spotify-builds-what-we-learned-and-fixed-about-quality-at-higher-velocity" rel="noopener noreferrer"&gt;AI Changed How Spotify Builds. What We Learned (and Fixed) About Quality at Higher Velocity&lt;/a&gt;. Anthropic also dropped perhaps one of the more interested pieces on this topic, looking at how they approach doing review at scale in &lt;a href="https://claude.dev/blog/solving-code-review-at-anthropic/" rel="noopener noreferrer"&gt;How the Claude Code team does code review&lt;/a&gt;, and one of the authors also pencilled another in this topic that is also worth reading, &lt;a href="https://addyo.substack.com/p/agentic-verification" rel="noopener noreferrer"&gt;Agentic Verification&lt;/a&gt;. Anthropic also published a recipe in their Claude Cookbook that walks you through creating a scheduled reviewer for your repo, and it is well worth implementing this recipe. Go check it out (and other really cool recipes the folks are sharing), &lt;a href="https://platform.claude.com/cookbook/claude-agent-sdk-scheduled-repository-reviewer-scheduled-repository-reviewer" rel="noopener noreferrer"&gt;Building a scheduled repository reviewer&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Must reads this week
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://code.claude.com/docs/en/advisor" rel="noopener noreferrer"&gt;Escalate hard decisions with the advisor tool&lt;/a&gt; is an experimental feature within Claude Code that I will admit I did not know about it until I heard about it during a meetup I attended this week (remember folks, meetups are super valuable for learning these sorts of things!). This feature allows you to use cheaper models, and then when needed, advisor will kick in and consult stronger models when needed (for example, if its bumping into repeating errors, or before, task is completed)&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.anthropic.com/engineering/redesigning-source-control" rel="noopener noreferrer"&gt;Redesigning source control at Anthropic&lt;/a&gt; is an interesting post that looks at some of the engineering choices that Anthropic are making when it comes to how to make source control work at agentic engineering speed. Scion is their bet, and its unlikely that many will find themselves in need of implementing their own, but we are seeing folks already working on improving the scaling capabilities of git, so who knows.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Watch this
&lt;/h2&gt;

&lt;p&gt;Zach Lloyd, founder and CEO of Warp did a talk at the AI Engineer conference in New York last week, talking about the software factory they built to help them manage the open sourcing of their Warp terminal (agent control plane). There is a lot of good stuff in this, including the detailed workflow and sample repo you can try for yourself. At Indicium AI we also help our customers implement software factories, and the architecture in this session had a lot of similarities to the approach we have taken, so lots of nodding from me.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/tUPPVhBBcoM" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  Tools to try out
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Third-party tools links are provided as-is. They belong to their owners, follow their own licenses, and are used at your own risk.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/davila7/claude-code-templates" rel="noopener noreferrer"&gt;claude-code-templates&lt;/a&gt; - I was drawn to this repo because Daniel San put together a really cool Claude Code mod that lets you inspect whats inside your context window at every turn, but then got lost in all the other cool stuff Daniel has been putting together. Defo a repo to spend some time exploring.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/init-co-jp/diff-tour" rel="noopener noreferrer"&gt;diff-tour&lt;/a&gt; - this is a really neat idea, that follows a thread of similar other tools in this space. How can you make it easier to reviews to walk through your diffs during PR reviews. diff-tour attempts to solve this by creating guided walk throughs the way a senior engineer might do. Works with a number of coding agents, including Claude Code.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/tt-a1i/archify" rel="noopener noreferrer"&gt;archify&lt;/a&gt; - is a tool that I am looking forward to trying out, especially in some of the code modernisation and onboarding use cases I am helping customers with. The tool uses agents to create beautiful interactive experiences that help you navigate and understand how a project or codebase works. It works with multiple coding harnesses, including Claude Code, and is one of the better tools in this space.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/alinaqi/mixture-of-models-claude-mod" rel="noopener noreferrer"&gt;mixture-of-models-claude-mod&lt;/a&gt; - is a neat tool that allows you to provide dynamic routing of requests to your Anthropic models or cheaper, locally hosted ones. Similar to how Kiro's Auto mode works, but this one allows you to do this from within your Claude sessions. Requires a bit of fiddling, but if you like that sort of thing, give it a go.&lt;/p&gt;

&lt;h2&gt;
  
  
  From the field
&lt;/h2&gt;

&lt;p&gt;This week, everyone has been talking about reverse engineering with agents. Whether that is using tools like &lt;a href="https://github.com/morluto/rea" rel="noopener noreferrer"&gt;rea&lt;/a&gt;, or one-shotting using the latest generation models, my socials are full of folks beginning to share what they are doing with it (&lt;a href="https://www.tomshardware.com/tech-industry/artificial-intelligence/dev-used-ai-agents-and-more-than-500-billion-tokens-to-rebuild-call-of-duty-modern-warfare-2s-source-code-83-percent-of-the-2009-shooters-functions-now-match-the-original-byte-for-byte" rel="noopener noreferrer"&gt;including this cool one&lt;/a&gt; that looks at how gamers are using it). I am interested as I can see some practical use cases for this in code modernisation use cases where perhaps source code is not available or the confidence is low. Have you checked it out yet? &lt;/p&gt;




&lt;p&gt;&lt;em&gt;If you enjoyed this, then remember to subscribe to the IndiciumAI blog so that you can keep up to date with future editions of this newsletter, as well as other great content that technologists at IndiciumAI will publish.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>developer</category>
    </item>
    <item>
      <title>Should we Kill Plan Mode? A Case for Keeping it in Claude Code.</title>
      <dc:creator>Alistair Heath</dc:creator>
      <pubDate>Mon, 12 Oct 2026 14:24:34 +0000</pubDate>
      <link>https://dev.to/indiciumai/should-we-kill-plan-mode-a-case-for-keeping-it-in-claude-code-gk9</link>
      <guid>https://dev.to/indiciumai/should-we-kill-plan-mode-a-case-for-keeping-it-in-claude-code-gk9</guid>
      <description>&lt;p&gt;&lt;em&gt;Plan Mode was built for the model. The case for keeping it is about the user.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Last week, Thariq Shihipar, an Engineer working on Claude Code at Anthropic posted on X suggesting that the Claude Code Team are thinking of killing Plan Mode, a specific mode in Claude which prompts the user to fully articulate the software they want to build.&lt;/p&gt;

&lt;p&gt;&lt;iframe class="tweet-embed" id="tweet-2102813194196758746-946" src="https://platform.twitter.com/embed/Tweet.html?id=2102813194196758746"&gt;
&lt;/iframe&gt;

  // Detect dark theme
  var iframe = document.getElementById('tweet-2102813194196758746-946');
  if (document.body.className.includes('dark-theme')) {
    iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2102813194196758746&amp;amp;theme=dark"
  }



&lt;/p&gt;

&lt;p&gt;Soon influential voices in the AI Engineering space shared their views, agreeing with that direction.&lt;/p&gt;

&lt;p&gt;&lt;iframe class="tweet-embed" id="tweet-2103197425880211644-972" src="https://platform.twitter.com/embed/Tweet.html?id=2103197425880211644"&gt;
&lt;/iframe&gt;

  // Detect dark theme
  var iframe = document.getElementById('tweet-2103197425880211644-972');
  if (document.body.className.includes('dark-theme')) {
    iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2103197425880211644&amp;amp;theme=dark"
  }



&lt;/p&gt;

&lt;p&gt;&lt;iframe class="tweet-embed" id="tweet-2102817442347032583-699" src="https://platform.twitter.com/embed/Tweet.html?id=2102817442347032583"&gt;
&lt;/iframe&gt;

  // Detect dark theme
  var iframe = document.getElementById('tweet-2102817442347032583-699');
  if (document.body.className.includes('dark-theme')) {
    iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2102817442347032583&amp;amp;theme=dark"
  }



&lt;/p&gt;

&lt;p&gt;I work as an AI Engineer at &lt;a href="https://indicium.ai" rel="noopener noreferrer"&gt;Indicium AI&lt;/a&gt;, a global, AI-native data and AI consultancy partnered with Anthropic, and I work with clients helping their engineering teams to adopt Claude Code. I’ve previously run Claude Code workshops with our clients and one of the first features we teach is how to use &lt;code&gt;Shift+Tab&lt;/code&gt; to start Plan Mode, so naturally I reflected on these proposed changes and the reason we have Plan Mode at all.&lt;/p&gt;

&lt;p&gt;It all starts with Peter Steinberger’s claim that Plan Mode is “for a different age”.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why Did We Have Plan Mode?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If you’re an engineer, you’ve seen and probably experienced the magical moment when you type &lt;em&gt;anything&lt;/em&gt; into Claude Code and the &lt;em&gt;thing&lt;/em&gt;, which would have taken hours or days, is built. But that’s exactly the problem for Claude, you could put &lt;em&gt;anything&lt;/em&gt; in that text field_. Anything_ from a small task to commissioning a whole new piece of software.&lt;/p&gt;

&lt;p&gt;When Claude Code first came out, Plan Mode was a way for Claude to collect requirements for those bigger asks, and reply with questions about how you want something done. It signposted to the Agent that, this was a big task so spend time collecting the requirements, filling in the gaps in the user’s plan and breaking the requirements down into tasks. Plan Mode was specifically triggered like this so that the user could indicate the scale of the ask.&lt;/p&gt;

&lt;p&gt;The argument against Plan Mode now, is that model reasoning has improved to the point where models can intuitively tell the difference between a big project and a small task. We don’t need to do that sign posting.&lt;/p&gt;

&lt;p&gt;But if the Agent doesn’t need this signposting, who does need Plan Mode?&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What If Plan mode is For Us?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;When we think of Engineering Teams adopting Claude Code, it’s tempting to think that it’s as easy as throwing licenses and tokens at developers and letting them run wild with this powerful new technology. However, technology this capable demands new ways of working, of collaborating. It demands that we put structures in place to ensure code quality, transparency and engineer accountability.&lt;/p&gt;

&lt;p&gt;Plan Mode provides an initial way of working for engineers on that journey and acts as a quality control measure for organisations.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Plan Mode as a Way of Working&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;In my experience running Claude Code Workshops and helping teams design ways of working, the art to teaching Claude Code is not just teaching the tool (documentation can do that), it’s about designing and driving the behaviours and workflows that encourage team productivity whilst also ensuring that constraints are in place so the LLM produces code of a consistently high standard.&lt;/p&gt;

&lt;p&gt;Driving workflow adoption is hard. They usually have to be designed before they can be taught. Co-creating them with a team can help adoption, but getting leadership buy-in to do that work is often harder than getting approval for a workshop. A workshop is time-bound and built around a tangible tool. But with Plan Mode, a simple workflow is built right into the tool so it’s much easier to start that discussion.&lt;/p&gt;

&lt;p&gt;Plan then Do. It’s a workflow that people intuitively understand and Plan Mode mirrors this, acting as a gateway to a broader discussion about ways of working.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Plan Mode as Quality Assurance&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;There’s an old adage in Data Science: “garbage in, garbage out”. It’s the same for Claude Code.&lt;/p&gt;

&lt;p&gt;As discussed, this may no longer be true regarding the model’s ability, but it’s certainly true regarding the quality and detail of the request. This is the whole point of Spec-Driven Development and it’s why frameworks like /grill-me and SpecKit exist. This approach has arisen to make sure that the human drivers of Claude spend time thinking through their requirements in detail which then informs precisely how code is executed. Crucially, this also puts Engineers in a position to assume responsibility for their decisions.&lt;/p&gt;

&lt;p&gt;This then leads to more conscious inputs to a change, better decisions and ultimately ownership over one’s work.&lt;/p&gt;

&lt;p&gt;Yes, organisations should definitely consider using tools like Grill Me, SpecKit or OpenSpec, but Plan Mode is accessible to all from the moment that you install Claude and that sends a signal about how good software is built.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;So What Should Plan Mode Become?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;What if Plan Mode isn’t about putting the agent in Plan Mode? What if it is instead about putting the user in Plan Mode? What if we designed for this mantra?&lt;/p&gt;

&lt;p&gt;&lt;iframe class="tweet-embed" id="tweet-2102813194196758746-461" src="https://platform.twitter.com/embed/Tweet.html?id=2102813194196758746"&gt;
&lt;/iframe&gt;

  // Detect dark theme
  var iframe = document.getElementById('tweet-2102813194196758746-461');
  if (document.body.className.includes('dark-theme')) {
    iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2102813194196758746&amp;amp;theme=dark"
  }



&lt;/p&gt;

&lt;p&gt;As AI becomes more capable, the question shifts from “how do we get the best out of AI?” to “how does AI get the best out of us?”.&lt;/p&gt;

&lt;p&gt;I believe it’s when we put ourselves in Plan Mode that we get the most creativity out of people. Planning, and forethought more broadly, is how we best explore and articulate a problem and dream of a solution. Planning is how we shape our future with more than just a “vibe”. So, how do improve Plan Mode to achieve this?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;  Keep a Planning Tool in Claude Code dedicated to structuring the user’s planning, even if the model doesn’t need it.&lt;/li&gt;
&lt;li&gt;  Don’t collapse planning into an effort slider. Effort is how hard the model thinks. Planning is whether the human has decided.&lt;/li&gt;
&lt;li&gt;  Make Claude’s default behavior one of inquisitiveness that seeks to understand the user’s needs, desires and intentions.&lt;/li&gt;
&lt;li&gt;  Where context is provided, provoke second-order questions: blast radius, rollback, who owns the decision, what “done” looks like.&lt;/li&gt;
&lt;li&gt;  Persist decisions as a reviewable artifact for teams. This one of the benefits of /grill-me and SpecKit and it’s vital for decision traceability.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Removing Plan Mode outright risks reducing the role of human thought in defining the products shaping our future. In an age where speed is everything, having a planning &lt;em&gt;tool&lt;/em&gt; within Claude Code makes the &lt;em&gt;behaviour&lt;/em&gt; of pausing and planning permissible.&lt;/p&gt;

&lt;p&gt;Alistair Heath is a Forward Deployed Engineer specialising in AI Engineering at &lt;a href="https://indicium.ai" rel="noopener noreferrer"&gt;Indicium AI&lt;/a&gt;. Follow me on X &lt;a href="https://x.com/alistairheath" rel="noopener noreferrer"&gt;@alistairheath&lt;/a&gt; and &lt;a href="https://www.linkedin.com/in/alistair-heath-2884b467/" rel="noopener noreferrer"&gt;LinkedIn&lt;/a&gt;. All views are my own.&lt;/p&gt;

</description>
      <category>claude</category>
      <category>aiengineering</category>
      <category>claudecode</category>
      <category>ai</category>
    </item>
    <item>
      <title>Build without Limits - SDLC Briefing - Edition #1</title>
      <dc:creator>Ricardo Sueiras</dc:creator>
      <pubDate>Mon, 12 Oct 2026 12:30:39 +0000</pubDate>
      <link>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-edition-1-3m3o</link>
      <guid>https://dev.to/indiciumai/build-without-limits-sdlc-briefing-edition-1-3m3o</guid>
      <description>&lt;p&gt;&lt;em&gt;Hi! I am Ricardo Sueiras, leading SDLC transformation at Indicium AI. That means I get to  work with customers and help them understand how to use agentic AI to build software. New tools, practices and opinions turn up every week, and Build without Limits cuts through the noise. In each edition we put together a short, curated briefing on what's worth reading, watching and worth trying. You can skim it in five minutes and dive deeper wherever something catches your eye.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Top of Mind
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://vercel.com/blog/state-of-agent-skills" rel="noopener noreferrer"&gt;State of agent skills&lt;/a&gt; is a report from Vercel that looks at the state of agent skills, drawing from the data they have amassed from hosting the skills.sh registry (one of a few that are out there). Essential reading.&lt;/p&gt;

&lt;h2&gt;
  
  
  Must reads this week
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.olafalders.com/2026/09/16/git-worktree-gotchas" rel="noopener noreferrer"&gt;git workstree gotchas&lt;/a&gt; is required reading for those of us who run parallel sessions within the same repo. Some of the points raised in this post will be familiar with folk, but there were enough new ones to make this post interesting.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.linuxfoundation.org/hubfs/Research%20Reports/LFResearch_OptimizingDevEx_Report_091826.pdf?hsLang=en" rel="noopener noreferrer"&gt;Linux Foundation published its research into Developer Experience&lt;/a&gt;  that contains some nice check lists that you can review/use as you look into what is, and how to measure developer experience. Why does this matter? SDLC transformation using agentic AI is a key driver for improving developer experience, and many organisations are now beginning to spin up developer experience teams where agentic AI tooling and governance sit.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://claude.dev/blog/getting-started-with-claude-code-mods/" rel="noopener noreferrer"&gt;Getting started with Claude Code mods&lt;/a&gt; is the official launch post that walks you through what Claude Code mods are and how to build one. Beginning to see a few folk doing some cool things with this, so check this out.&lt;/p&gt;

&lt;h2&gt;
  
  
  Watch this
&lt;/h2&gt;

&lt;p&gt;Fixing the PR Bottleneck This week I spent some time on my commute watching the latest Matt Pocock knowledge drop on how to think and approach the review bottleneck in agentic engineering. Don't want to give too much away, but I think there are some really good perspectives here.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/LlgiOCmFG_w" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  Tools to try out
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Third-party tools links are provided as-is. They belong to their owners, follow their own licenses, and are used at your own risk.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/DeusData/codebase-memory-mcp" rel="noopener noreferrer"&gt;Codebase-memory-mcp&lt;/a&gt; is a local MCP server that turns your repo into a searchable knowledge graph of functions, calls, routes and dependencies. AI coding agents can then answer questions like "what calls this?" or "what breaks if I change this?" with one query, instead of reading through files one at a time. This is really handy if you are tackling code modernisation or supporting legacy tech stacks, something that we at Indicium AI are increasingly helping customers with.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/theBstar/shipreel" rel="noopener noreferrer"&gt;Shipreel&lt;/a&gt; is a neat tool that helps you create visuals (video), turning a pull request into a short narrated walkthrough video. It uses your harness to read the diff, write a story, draw the diagrams, record the real app if the change has a UI, and then render a compact MP4, about two and a half minutes by default, with captions, crossfade cuts and an ambient music bed.&lt;/p&gt;

&lt;h2&gt;
  
  
  From the field
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.hrdive.com/news/should-workers-be-paid-for-ai-skills/830908/" rel="noopener noreferrer"&gt;Should workers be paid for AI skills?&lt;/a&gt; is a super interesting post that piqued my interest given  recent customer meetings that have flagged the topic of how much is the premium for AI competent engineers, and what flight risk do they present to an organisation if they train their existing engineers in AI. Are you seeing this in your organisation? &lt;/p&gt;




&lt;p&gt;&lt;em&gt;If you enjoyed this, then remember to subscribe to the IndiciumAI blog so that you can keep up to date with future editions of this newsletter, as well as other great content that technologists at IndiciumAI will publish.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>developer</category>
    </item>
    <item>
      <title>A Simple Guide to Passing the Claude Certified Developer Exam</title>
      <dc:creator>Haider Rasool</dc:creator>
      <pubDate>Fri, 09 Oct 2026 09:01:11 +0000</pubDate>
      <link>https://dev.to/indiciumai/a-simple-guide-to-passing-the-claude-certified-developer-exam-4g3c</link>
      <guid>https://dev.to/indiciumai/a-simple-guide-to-passing-the-claude-certified-developer-exam-4g3c</guid>
      <description>&lt;p&gt;I passed the Claude Certified Developer – Foundations (CCDV-F) exam with a score of &lt;strong&gt;941&lt;/strong&gt;. The pass mark is &lt;strong&gt;720&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The exam only launched in July 2026, so there isn't much prep material out there yet. No Udemy course, no well-worn Reddit threads, no "top 50 questions" gists. So I did the obvious thing for an exam about Claude: I used Claude to prepare for it.&lt;/p&gt;

&lt;p&gt;Here's the exact workflow, the prompts, and what I'd tell anyone sitting it next.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Step 1: Turn the exam guide into mock exams&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Start with the official scope. I used this &lt;a href="https://claudecertificationguide.com/blog/claude-certified-developer-foundations-exam-guide" rel="noopener noreferrer"&gt;CCDV-F exam guide&lt;/a&gt;, which lays out the domains the exam covers.&lt;/p&gt;

&lt;p&gt;I pasted the guide into Claude and asked it to generate full mock exams from it. My setup:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Model:&lt;/strong&gt; Opus. For generating realistic, well-reasoned questions and explanations, the extra horsepower is worth it.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tool:&lt;/strong&gt; Cowork. It handles multi-step tasks well and can save each mock exam as a file you can come back to.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A prompt along these lines works well:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Here is the exam guide for the Claude Certified Developer – Foundations exam.

&amp;lt;COPY PASTE SCOPE HERE&amp;gt;

Generate a full-length mock exam that covers every domain in the guide,weighted the way the guide weights them. Use the same question style as the real exam. Don't show the answers until I've submitted mine, then mark me and explain why each wrong answer was wrong.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  &lt;strong&gt;Step 2: Over-prepare with a harder difficulty&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;If you want to over-prepare (I did), ask Claude to make the mocks &lt;em&gt;harder&lt;/em&gt; than it thinks the real exam will be. Think of it as load testing: if you're comfortable under peak traffic, normal traffic is easy.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Generate another mock exam, but make it noticeably harder than you
expect the real exam to be: trickier distractors, more edge cases,
and questions that combine multiple domains.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;My mix:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Mock exams&lt;/th&gt;
&lt;th&gt;Difficulty&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;Harder than expected&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;Normal&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The real exam was nowhere near as difficult as the harder mocks. That gap is exactly what you want walking in. The other added benefit is that you will learn more and it will sharpen you as an Engineer.&lt;/p&gt;

&lt;p&gt;As you go, &lt;strong&gt;log every question you get wrong&lt;/strong&gt;. A simple running list works: the question, your answer, the right answer, and one line on why. That list becomes your revision material at the end. You can also ask Claude to keep it for you in a file inside Cowork.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Step 3: Questions first, theory second&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Only after a few mocks did I ask Claude for a summary of the facts and concepts to remember for the exam.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Based on the exam guide and the questions I got wrong (attached),
give me a concise summary of the key facts and concepts I need to
know for the exam. Prioritise the areas where I made mistakes.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The order matters. It's the same reason you understand a codebase faster after debugging it than after reading the docs cold. Once you've wrestled with a question and got it wrong, the theory behind it is no longer abstract. It answers a question you already care about, so it's more interesting and much more likely to stick.&lt;/p&gt;

&lt;p&gt;In the last few days, go back through your list of wrong answers alongside the summary.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Where to focus: follow the weightings&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;I didn't hit a domain that felt especially hard, and I scored close to 100% in most of them. So rather than pointing at a tricky topic, my advice is to budget your study time by the blueprint weights. The exam has 53 questions across eight domains, and the weighting is very uneven (&lt;a href="https://claudecertificationguide.com/blog/claude-certified-developer-foundations-exam-guide" rel="noopener noreferrer"&gt;source&lt;/a&gt;).&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Domain&lt;/th&gt;
&lt;th&gt;Weight&lt;/th&gt;
&lt;th&gt;Tip&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Applications and Integration&lt;/td&gt;
&lt;td&gt;33.1%&lt;/td&gt;
&lt;td&gt;If you haven't built against the Claude API before, a small hands-on project will make these questions click. Make sure it covers auth, requests, streaming, error handling and config. If you've built with the API before, mock exams and a skim of the docs are enough.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Model Selection and Optimisation&lt;/td&gt;
&lt;td&gt;16.8%&lt;/td&gt;
&lt;td&gt;Know the trade-offs between model tiers and how token usage drives cost. Be ready to pick a model for a given job.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agents and Workflows&lt;/td&gt;
&lt;td&gt;14.7%&lt;/td&gt;
&lt;td&gt;Understand the agent loop and common patterns. Building one simple agent teaches more than reading about many.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Prompt and Context Engineering&lt;/td&gt;
&lt;td&gt;11.0%&lt;/td&gt;
&lt;td&gt;Practise structured prompts and output handling. Know what belongs in context and what doesn't.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tools and MCPs&lt;/td&gt;
&lt;td&gt;10.6%&lt;/td&gt;
&lt;td&gt;Define a tool, then stand up a minimal MCP server. The moving parts click once you've wired them yourself.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Security and Safety&lt;/td&gt;
&lt;td&gt;8.1%&lt;/td&gt;
&lt;td&gt;Treat it like any production app: secrets out of code, keys managed properly, guardrails on inputs and outputs.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claude Code&lt;/td&gt;
&lt;td&gt;3.1%&lt;/td&gt;
&lt;td&gt;Light weight. If you use it day to day, you're probably covered.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Eval, Testing, and Debugging&lt;/td&gt;
&lt;td&gt;2.6%&lt;/td&gt;
&lt;td&gt;Light weight. Know the common API errors and how to handle them.&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The top three domains make up nearly two-thirds of the marks. If you're short on time, start there.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;On the exam day&lt;/strong&gt;
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Read every question thoroughly.&lt;/strong&gt; The detail that decides the answer is often in the last line.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pick the answer that makes sense in practice.&lt;/strong&gt; Plenty of questions come down to thinking like a software engineer on the job. If an option is technically possible but nobody would ship it, it's probably a distractor.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Don't panic about time.&lt;/strong&gt; You get 2 hours. I finished in about 70 minutes with no rush, so there's room to re-read the questions you're unsure of. There’s also an option to flag questions and come back to them at the end.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;TL;DR&lt;/strong&gt;
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Feed the exam guide to Claude (Opus, in Cowork) and generate mock exams.
&lt;/li&gt;
&lt;li&gt;Do 2 harder-than-real mocks and 2 normal ones.
&lt;/li&gt;
&lt;li&gt;Log every question you get wrong.
&lt;/li&gt;
&lt;li&gt;Only then ask Claude for a summary of key facts and concepts.
&lt;/li&gt;
&lt;li&gt;Revise your wrong answers alongside the summary.
&lt;/li&gt;
&lt;li&gt;On the day: read carefully, think practically.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Good luck. If you've sat the exam too, drop your tips in the comments.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>career</category>
      <category>claude</category>
      <category>learning</category>
    </item>
  </channel>
</rss>
