<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>javierdecarli.com</title>
    <link>http://javierdecarli.com/</link>
    <description>Recent content on javierdecarli.com</description>
    <generator>Hugo</generator>
    <language>en-us</language>
    <lastBuildDate>Tue, 03 Nov 2026 00:00:00 +0000</lastBuildDate>
    <atom:link href="http://javierdecarli.com/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>A case for unit tests</title>
      <link>http://javierdecarli.com/posts/a-case-for-unit-tests/</link>
      <pubDate>Tue, 03 Nov 2026 00:00:00 +0000</pubDate>
      <guid>http://javierdecarli.com/posts/a-case-for-unit-tests/</guid>
      <description>Why I think AI makes them more important, not less</description>
      <content:encoded><![CDATA[<p>There&rsquo;s a lot of chat going around on what is the role of unit tests in this AI age. Are they still useful? are they an artifact from the past where the code was more human-driven and we needed those guardrails to make sure we don&rsquo;t break pre-existing behavior? or are they really useful for more than testing the written code?</p>
<p>So&hellip; this is my take and why I <strong><em>do</em></strong> think not only they are necessary but more important than ever, which is a bit connected to all the advantages I see outside of the popular/most commonly referred one.</p>
<h2 id="act-as-first-safety-net">Act as first safety net</h2>
<p>This is in my opinion the classic and most commonly referred as the &ldquo;main reason&rdquo; why we add unit tests. We want to have a first pass through all our unit tests to make sure we didn&rsquo;t &ldquo;break anything else&rdquo; while doing new development, acting as some sort of &ldquo;soft&rdquo; regression. <sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup></p>
<p>So, the main question here should be&hellip; does this still happen? are agents so powerful they have total and complete visibility of the code they are changing and my answer is <strong><em>definitely no</em></strong>, at least not on real software development projects. <sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup></p>
<p>Of course, It clearly depends a lot on the size of the solution, but same happens with us humans, and it almost happens for the same reasons which is the context of the problem (in our case that context is how much can we predict ahead of us, in &ldquo;ai agents&rdquo; is more about how much context memory they can load)</p>
<blockquote>
<p><strong>Summary</strong>: Still useful but very dependent on the type and size of project. Clearly not necessary if we&rsquo;re doing a small proof of concept or a bunch of scripts.</p>
</blockquote>
<h2 id="they-lock-down-behavior">They lock down behavior</h2>
<p>Apart from testing, if the <em>unit at test</em> fulfills the promise, we should also lock that behavior down.</p>
<p>By &ldquo;locking the behavior down&rdquo; I refer to having a unit test that unless the expected behavior is accomplished it won&rsquo;t pass, blocking the build from happening. If we want to achieve this the test must cover what the method receives as an input and what the resulting value must be.</p>
<p>Last but not least, it&rsquo;s important the test covers the important scenarios and edge cases or else not only we have a <em>partially covered unit</em> but we&rsquo;re not really <em>locking down</em> the behavior.</p>
<p><a href="https://learn.microsoft.com/en-us/dotnet/core/testing/mutation-testing">Mutation Testing</a> sounds like an effective way to identify if the unit test actually locks down behavior. To be honest, I need to investigate a bit about tools and what their capabilities are.</p>
<blockquote>
<p><strong>Summary</strong>: Depending on the size and intent of the actual solution I see is worth paying attention to this. I also see it could be useful on scenarios with shared contracts between different apps.</p>
</blockquote>
<h2 id="they-document-behavior">They document behavior</h2>
<p>Very connected with the concept of locking down behavior (previous point). Before AI it was important because, if the unit test was complete and well-done <sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup>, you didn&rsquo;t have to go on a crazy rabbit-hole searching for documentation. You could use a well done unit test to understand what was the code trying to do, and use experience and good judgment to understand the whole context.</p>
<p>With AI it can change the outcome of what an agent do. I&rsquo;ve seen agents change their understanding after a unit test confirmed or denied a particular behavior so tests are one of the few ways <a href="http://javierdecarli.com/posts/the-age-of-software-decision-making/">to hand an agent the context it doesn&rsquo;t have</a>. They certainly <strong><em>act as a feedback loop</em></strong>.</p>
<blockquote>
<p><strong>Summary</strong>: After seeing how some agents behave, I think <strong><em>today</em></strong> this could be one of the most important factors of having <em><strong>well written</strong></em> unit tests. A wrong unit test can confuse an agent into thinking the method&rsquo;s intent is different.</p>
</blockquote>
<h2 id="conclusion">Conclusion</h2>
<p>A unit test records not &ldquo;what does the code do&rdquo; but &ldquo;what is it supposed to do&rdquo; and sometimes the reasons for that logic are business rules.</p>
<p>Not only I feel unit tests are relevant nowadays, but I feel they are almost a necessity. Obviously, this isn&rsquo;t a one-size-fits all, there are different projects sizes and things, but the overall idea is that an agent that run tests can check its own work and fix its mistakes without interaction.</p>
<p>Without tests, it says &ldquo;done&rdquo; and you&rsquo;re the test suite.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>I say &ldquo;soft&rdquo; regression because there are no integrations with other systems (like APIs or DBs).&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>And I doubt ever will, because it&rsquo;s just not possible to know all possible outcomes for every combination, and even if an agent could predict every outcome, it still wouldn&rsquo;t know which outcomes are right. Predicting that <code>calculateDiscount(100)</code> returns <code>90</code> doesn&rsquo;t tell you whether the business wanted <code>90</code> or <code>85</code>. That knowledge lives with the people who own the problem, which is Brooks&rsquo;s <em>essential complexity</em> which was <a href="http://javierdecarli.com/posts/the-age-of-software-decision-making/">discussed in other post</a>.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>I know I know&hellip; use your imagination for a moment, it&rsquo;s an example. Let&rsquo;s imagine for a moment the unit tests are <em>complete</em> and <em>well-done</em> 🤣.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Claude Code setup 101</title>
      <link>http://javierdecarli.com/posts/claude-code-setup-101/</link>
      <pubDate>Sun, 04 Oct 2026 00:00:00 +0000</pubDate>
      <guid>http://javierdecarli.com/posts/claude-code-setup-101/</guid>
      <description>Minimum knowledge required for better results</description>
      <content:encoded><![CDATA[<blockquote>
<p><strong>UPDATE 2026-11-11</strong> / Added diagrams, the Permissions section, fixed some typos and some information on when each when the tool-call hooks run.</p>
</blockquote>
<p>It&rsquo;s pretty important to have a tight control on how our Claude Code is configured. The more we understand how it&rsquo;s set, the more confident we can be that our agents will do what we want them to do, and avoid unwanted consequences.</p>
<blockquote>
<p>As we&rsquo;re in the infancy of this tech, and things change very quickly, have in mind I&rsquo;m writing this on <strong><em>October 2026</em></strong>, and things might change drastically in the future.</p>
</blockquote>
<h2 id="understanding-configuration-levels">Understanding configuration levels</h2>
<p>Claude has 3 levels worth mentioning</p>
<ol>
<li><strong>Enterprise-level</strong>: This is the highest level and the one we have the least control. This is meant for your organization to push rules/restrictions to your harness. If you use Claude outside an organization (just for yourself), you can disregard this.</li>
<li><strong>User-level</strong>: These are configurations that rule all projects in our machine.</li>
<li><strong>Project-level</strong>: Rules that affect <em><strong>only the session</strong></em> started from that specific folder/workspace.</li>
</ol>
<p>To make things a bit more visual, an example would look like this:</p>
<pre class="mermaid">
flowchart TB
    E[&#34;Enterprise · set by your org&lt;br/&gt;block reading .env files&#34;]
    U[&#34;User-level · ~/.claude/&lt;br/&gt;model: opus&#34;]
    A[&#34;Project A · my-blog/.claude/&lt;br/&gt;nothing set&#34;]
    B[&#34;Project B · work-api/.claude/&lt;br/&gt;model: sonnet&#34;]
    SA([&#34;Session in A&lt;br/&gt;opus · .env blocked&#34;])
    SB([&#34;Session in B&lt;br/&gt;sonnet · .env blocked&#34;])

    U --&gt;|applies to every project| A
    U --&gt; B
    A --&gt; SA
    B --&gt;|overrides the user-level model| SB
    E -.-&gt;|always wins, can&#39;t be overridden| SA
    E -.-&gt; SB
</pre>

<p>The user-level sets the defaults for every project (here, <code>model: opus</code>). A project can override them just for its own sessions, like Project B switching to <code>sonnet</code>, while Project A keeps the user default. It works a lot like git&rsquo;s global and local config.</p>
<p>The enterprise level sits on top of everything: its rules reach every session and can&rsquo;t be overridden from below.</p>
<h2 id="deterministic-vs-non-deterministic-rules-and-constrains">Deterministic vs non-deterministic rules and constrains</h2>
<p>There are reasons why we would add rules or constraints in different places.</p>
<p>All of the options below can live at any of the levels above (<code>~/.claude/</code> for the user-level, the project folder for the project-level). One difference though is <code>CLAUDE.MD</code> files don&rsquo;t override each other like settings do. Claude loads all of them together, so our user-level and project-level instructions <em><strong>add up</strong></em>.</p>
<h3 id="claudemd">CLAUDE.MD</h3>
<p>Claude&rsquo;s main entry point. This file will always be read first, loaded into the context and, most of the time, be the main set of instructions.</p>
<blockquote>
<p><strong><em>ANYWAYS&hellip;</em></strong> rules like &ldquo;don&rsquo;t use X tool&rdquo; or &ldquo;never execute Y&rdquo; are honestly a hit and miss. Many times I got to remind Claude to stop doing something I added in my user level <code>CLAUDE.MD</code> just to get the classic &ldquo;oh right, sorry, I missed that, it won&rsquo;t happen again&rdquo;. Permissions or hooks are the way to go for those cases.</p>
</blockquote>
<p>Keep more broad, less important information here, like &ldquo;response style&rdquo; or &ldquo;verbosity level&rdquo; because <code>CLAUDE.MD</code> is non-deterministic. <sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup></p>
<p>Also, keep this file as short as possible because this is information that is loaded in the &ldquo;context&rdquo;, that context is finite and we need it. Even though Anthropic doesn&rsquo;t provide a specific number, general consensus is less that 200 lines is good, less than 60 ideal. <sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup></p>
<h3 id="permissions">Permissions</h3>
<p>For simple cases like &ldquo;never execute Y&rdquo;, the easiest option is a deny rule in <code>settings.json</code>. This type of rules are deterministic <sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> and Claude can&rsquo;t run what&rsquo;s denied.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;permissions&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;deny&#34;</span><span class="p">:</span> <span class="p">[</span><span class="s2">&#34;Bash(rm -rf *)&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>A deny rule wins <em>at any level</em>, so a project can&rsquo;t allow something we denied at the user-level. The catch is that it only matches the command text so a <code>Bash(rm -rf *)</code> won&rsquo;t stop <code>/bin/rm -rf</code> from running. For a harder boundary, or anything more complex, we will need hooks.</p>
<h3 id="hooks">Hooks</h3>
<p>Hooks, same as permissions, are deterministic. Just like git hooks, these will <em>always</em> be executed upon certain events.</p>
<p>Based on below categories, the events are:</p>
<table>
	<thead>
			<tr>
					<th>Category</th>
					<th>Events</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Session</td>
					<td><code>SessionStart</code>, <code>Setup</code>, <code>SessionEnd</code></td>
			</tr>
			<tr>
					<td>Turn</td>
					<td><code>UserPromptSubmit</code>, <code>UserPromptExpansion</code>, <code>Stop</code>, <code>StopFailure</code></td>
			</tr>
			<tr>
					<td>Agentic Loop</td>
					<td><code>PreToolUse</code>, <code>PermissionRequest</code>, <code>PermissionDenied</code>, <code>PostToolUse</code>, <code>PostToolUseFailure</code>, <code>PostToolBatch</code></td>
			</tr>
			<tr>
					<td>Agent/Team</td>
					<td><code>SubagentStart</code>, <code>SubagentStop</code>, <code>TeammateIdle</code>, <code>TaskCreated</code>, <code>TaskCompleted</code></td>
			</tr>
			<tr>
					<td>File/Environment</td>
					<td><code>InstructionsLoaded</code>, <code>ConfigChange</code>, <code>CwdChanged</code>, <code>FileChanged</code>, <code>WorktreeCreate</code>, <code>WorktreeRemove</code>, <code>PreCompact</code>, <code>PostCompact</code></td>
			</tr>
			<tr>
					<td>Notifications</td>
					<td><code>Notification</code></td>
			</tr>
	</tbody>
</table>
<p>And at this point in time:</p>
<table>
	<thead>
			<tr>
					<th>When</th>
					<th>Hook events</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Before the tool call, ahead of the permission rules</td>
					<td><code>PreToolUse</code></td>
			</tr>
			<tr>
					<td>When the call needs a permission decision (e.g. Claude is about to ask us)</td>
					<td><code>PermissionRequest</code></td>
			</tr>
			<tr>
					<td>When auto mode denies the call</td>
					<td><code>PermissionDenied</code></td>
			</tr>
			<tr>
					<td>After the call succeeds</td>
					<td><code>PostToolUse</code></td>
			</tr>
			<tr>
					<td>After the call fails</td>
					<td><code>PostToolUseFailure</code></td>
			</tr>
			<tr>
					<td>After a batch of parallel calls finishes, before Claude&rsquo;s next step</td>
					<td><code>PostToolBatch</code></td>
			</tr>
	</tbody>
</table>
<p>And also based on those events there&rsquo;s supports for multiple handler types (per documentation <sup id="fnref:4"><a href="#fn:4" class="footnote-ref" role="doc-noteref">4</a></sup>):</p>
<table>
	<thead>
			<tr>
					<th>Handler Type</th>
					<th>Description</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Command hooks</td>
					<td>Run shell commands (most common)</td>
			</tr>
			<tr>
					<td>HTTP hooks</td>
					<td>POST to an endpoint</td>
			</tr>
			<tr>
					<td>Prompt hooks</td>
					<td>Ask a Claude model to decide (e.g. allow or block)</td>
			</tr>
			<tr>
					<td>Agent hooks</td>
					<td>Spawn subagents</td>
			</tr>
			<tr>
					<td>MCP tool hooks</td>
					<td>Call MCP tools directly</td>
			</tr>
	</tbody>
</table>
<p>For example, this is how the &ldquo;never execute Y&rdquo; rule from the <code>CLAUDE.MD</code> section looks as a hook. It runs before every Bash command and blocks <code>rm -rf</code>, no matter what Claude &ldquo;remembers&rdquo;. In <code>.claude/settings.json</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;hooks&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;PreToolUse&#34;</span><span class="p">:</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">      <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nt">&#34;matcher&#34;</span><span class="p">:</span> <span class="s2">&#34;Bash&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="nt">&#34;hooks&#34;</span><span class="p">:</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">          <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nt">&#34;type&#34;</span><span class="p">:</span> <span class="s2">&#34;command&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="nt">&#34;command&#34;</span><span class="p">:</span> <span class="s2">&#34;${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh&#34;</span>
</span></span><span class="line"><span class="cl">          <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">]</span>
</span></span><span class="line"><span class="cl">      <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>And the script, <code>.claude/hooks/block-rm.sh</code> would be something like:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="cp">#!/bin/bash
</span></span></span><span class="line"><span class="cl"><span class="nv">COMMAND</span><span class="o">=</span><span class="k">$(</span>jq -r <span class="s1">&#39;.tool_input.command&#39;</span><span class="k">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="nb">echo</span> <span class="s2">&#34;</span><span class="nv">$COMMAND</span><span class="s2">&#34;</span> <span class="p">|</span> grep -q <span class="s1">&#39;rm -rf&#39;</span><span class="p">;</span> <span class="k">then</span>
</span></span><span class="line"><span class="cl">  jq -n <span class="s1">&#39;{
</span></span></span><span class="line"><span class="cl"><span class="s1">    hookSpecificOutput: {
</span></span></span><span class="line"><span class="cl"><span class="s1">      hookEventName: &#34;PreToolUse&#34;,
</span></span></span><span class="line"><span class="cl"><span class="s1">      permissionDecision: &#34;deny&#34;,
</span></span></span><span class="line"><span class="cl"><span class="s1">      permissionDecisionReason: &#34;Destructive command blocked by hook&#34;
</span></span></span><span class="line"><span class="cl"><span class="s1">    }
</span></span></span><span class="line"><span class="cl"><span class="s1">  }&#39;</span>
</span></span><span class="line"><span class="cl"><span class="k">fi</span>
</span></span></code></pre></div><p>To visualize this whole explanation better, this is a flow diagram of how hooks and permissions would behave during our bash <code>rm -rf</code> example</p>
<pre class="mermaid">
flowchart TB
    C[&#34;Claude wants to run a Bash command&#34;] --&gt; H{&#34;PreToolUse hook&lt;br/&gt;block-rm.sh&#34;}
    H --&gt;|&#34;contains rm -rf&lt;br/&gt;(also /bin/rm -rf)&#34;| XH[&#34;Blocked by the hook&#34;]
    H --&gt;|&#34;no match, or the hook failed&#34;| P{&#34;Permission rules&lt;br/&gt;deny, then ask, then allow&#34;}
    P --&gt;|&#34;matches Bash(rm -rf *)&#34;| XP[&#34;Blocked by the deny rule&#34;]
    P --&gt;|allowed| R[&#34;Command runs&#34;]
</pre>

<p>The hook runs first, before the permission rules <sup id="fnref:5"><a href="#fn:5" class="footnote-ref" role="doc-noteref">5</a></sup>. It catches any command containing <code>rm -rf</code>, including the <code>/bin/rm -rf</code> that the deny rule misses. If the hook can&rsquo;t decide (no match, or it failed, for example because <code>jq</code> isn&rsquo;t installed), the command moves on to the permission rules, and the deny rule is still there as a safety net. Each one covers what the other can miss.</p>
<p>There&rsquo;s no need to memorize anything here, but understanding different levels and the capabilities and limitations that exist, gives us higher chances at getting better results. That should be enough to know when to ask our agent to add a hook or a permission rule, and at what level depending our workflow.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>&ldquo;Non-Deterministic AI&rdquo; can yield different outputs from the same input due to its reliance on probabilities and variability.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>These are very generic numbers that don&rsquo;t have into account how many <code>CLAUDE.MD</code> files our repo has (because it can contain many) or how much data we&rsquo;re loading into the context.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>&ldquo;Deterministic AI&rdquo; produces the same output every time for a given input, ensuring predictability and repeatability.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:4">
<p>The documentation goes pretty deep into various topics like Lifecycle and even it provide some examples of event fires. Documentation in: <a href="https://code.claude.com/docs/en/hooks">https://code.claude.com/docs/en/hooks</a>&#160;<a href="#fnref:4" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:5">
<p>This particular hook (&ldquo;PreToolUse&rdquo;) runs before the permissions.&#160;<a href="#fnref:5" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Back to RSS</title>
      <link>http://javierdecarli.com/posts/going-back-to-rss/</link>
      <pubDate>Mon, 28 Sep 2026 00:00:00 +0000</pubDate>
      <guid>http://javierdecarli.com/posts/going-back-to-rss/</guid>
      <description>When ads and trackers completely destroy the experience</description>
      <content:encoded><![CDATA[<p>The web became a pretty hostile place to browse/navigate. It&rsquo;s almost mandatory to have an ad-blocker to stop intrusive ads, popups, trackers and other maliciuos content. And let&rsquo;s not even talk about mobile because the situation there is even worse.</p>
<p>I think this is making a lot of people to go back to more simple ways to get information. Of course, I don&rsquo;t think RSS will become popular but who knows. Anyways, I just added RSS support in case you want.</p>
<ul>
<li>Main RSS feed: <a href="https://javierdecarli.com/index.xml">https://javierdecarli.com/index.xml</a></li>
<li>Spanish RSS (in case you&rsquo;re interested): <a href="https://javierdecarli.com/es/index.xml">https://javierdecarli.com/es/index.xml</a></li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>The age of software decision making</title>
      <link>http://javierdecarli.com/posts/the-age-of-software-decision-making/</link>
      <pubDate>Wed, 02 Sep 2026 00:00:00 +0000</pubDate>
      <guid>http://javierdecarli.com/posts/the-age-of-software-decision-making/</guid>
      <description>Why I feel AI product generation will probably slow down</description>
      <content:encoded><![CDATA[<p>Talking with my friend <a href="https://sebasmonia.com/">Sebastian</a> we hit the topic of things that AI was helping us to achieve and also things that we dodged the bullet by steering the AI agent in the right direction, avoiding a bad &ldquo;long-term&rdquo; choice. These were situations where the AI agent went in one direction that was not the right one, or let&rsquo;s say, that <em>we know</em> would have bad consequences&hellip;</p>
<p>Those situations where you ask yourself &ldquo;But does it work?&rdquo; and the answer is yeah, for sure&hellip; but is not the right choice because it&rsquo;s either a problem in the long term, or a dead end, or maybe it&rsquo;s way too&hellip; &ldquo;myopic&rdquo;?</p>
<p>In some few cases could just be that the model might not be as strong as we think it is, but in most cases is definitely lack of context. Is the AIs fault for not knowing what is our final vision of the solution? well&hellip; that&rsquo;s pretty unfair. We are the only ones knowing the end goal of what we want to achieve, the AI only executes whatever we ask to solve &ldquo;right now&rdquo;. Same thing happens in all our (human) interactions, and has been happening forever.</p>
<p>Let&rsquo;s use this example: asking AI to generate a dashboard or a website. Everyone is doing this, and the non‑technical conclusion is always the same: “So fast! We don’t need developers anymore!” but how many users will consume that dashboard? One? Ten? Ten thousand? A million? The use case changes the implementation drastically. And what happens when we have 300 metrics? Where does metric 301 go? Does it belong on the first page? Is it redundant? Does it break the layout? The bigger the solution gets, the more complex developing and maintaining it becomes.</p>
<h2 id="these-are-not-new-problems">These are not new problems&hellip;</h2>
<p>Written in 1986 <a href="https://en.wikipedia.org/wiki/No_Silver_Bullet">&ldquo;No Silver Bullet—Essence and Accident in Software Engineering&rdquo;</a> is a paper on software engineering written by Fred Brooks that addresses the general problem. In that paper he brings two key concepts: &ldquo;accidental complexity&rdquo; and &ldquo;real complexity&rdquo;. <sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup></p>
<p>Accidental complexity is basically <em>problems that engineers create and can fix</em>. The technical details, the glue code, the integrations, the mechanics of walking the path toward the solution.</p>
<p>Essential complexity is <em>caused by the problem to be solved and nothing can remove it</em>. If users want a program to do 30 different things, then those 30 things are essential and the program must do those 30 different things.</p>
<p>Clearly Mr Brooks had no idea what AI would look like, but given how general the problem is, it&rsquo;s very relevant. AI addresses the accidental complexity and, given the right instructions and context, nails it but we&rsquo;re still left with a big chunk of the problem to solve.</p>
<h2 id="the-gap-between-knowing-and-understanding">The gap between knowing and understanding</h2>
<p>In Star Trek: The Next Generation there&rsquo;s an episode where Data (Lieutenant Commander Data which, if you never watch it, number one shame on you, number two he is an android) builds another android that he aids with cognitive and standard behavioral algorithms. During an interaction Data explains something that fits a problem perfectly but Picard (Commander Jean-Luc Picard) challenges him about whether the new android was learning, or whether she was simply executing algorithms to which Data responds:</p>
<p>“It is the difference between knowledge and experience.” <sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup></p>
<p>And I feel that’s exactly what happens with AI today.</p>
<p>The AI agent produces analysis, design, code, tests, even full PRs. But it never experienced the problem, or any similar problem. It doesn’t understand the long‑term vision, the constraints, the tradeoffs which are basically the intuition behind the design. And that means <em>the quality of the solution is directly proportional to the quality of the instruction</em>.</p>
<h2 id="conclusion">Conclusion</h2>
<p>I feel it&rsquo;s all about the final vision and the design to arrive to the solution because of factors like technology limitations and, more important, the essential complexity of each problem. The narrative that anybody can build software solutions is just very naive because it assumes the AI agent will magically have enough context to make decisions and fill the gaps.</p>
<p>Can this ever happen? hard to predict&hellip; it will definitely be alleviated by having much more processing power and not having to worry about who is the target of the solution, but the essential complexity will always be there.</p>
<p>It&rsquo;s as unavoidable as the need to solve new problems.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Does not mean an &ldquo;accident&rdquo; as used in common speech, a chance incident, normally harmful. Examples of accidents are color, taste, movement, and stagnation / <a href="https://en.wikipedia.org/wiki/Accident_%28philosophy%29">wikipedia source</a>&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>This is why the episode is called &ldquo;The Offspring&rdquo; - Episode 16th of the third season, and the 64th episode of the series overall / <a href="https://en.wikipedia.org/wiki/The_Offspring_%28Star_Trek:_The_Next_Generation%29">more detail</a>&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Transfering knowledge</title>
      <link>http://javierdecarli.com/posts/transfering-knowledge/</link>
      <pubDate>Sun, 09 Aug 2026 00:00:00 +0000</pubDate>
      <guid>http://javierdecarli.com/posts/transfering-knowledge/</guid>
      <description>Much harder that we all think it is</description>
      <content:encoded><![CDATA[<pre tabindex="0"><code>Tank: Let’s get to it…. Now, we’re supposed to start with these operation programs first, that’s major boring shit. Let’s do something a little more fun. How about combat training?
Neo: Jujitsu? I’m going to learn Jujitsu?… Holy shit.
Tank: Hey Mikey, I think he likes it. How about some more?
Neo: Hell yes.
Morpheus: How is he?
Tank: Ten hours straight. He’s… a machine.
Neo: I know Kung Fu.

Neo&#39;s training scene in the Nebuchadnezzar - The Matrix (1999)
</code></pre><p>I wish it was like that, huh?</p>
<p>Sharing knowledge/teaching/showing other people how to do things is a difficult process. Not only is it difficult but also mostly underestimated. For the &ldquo;untrained eye&rdquo;, teaching sounds simple until you actually have to do it.</p>
<h2 id="learning-is-messy">Learning is messy</h2>
<p>We all learn in different ways. Some people learn in a visual way (using mental maps, diagrams or other techniques), some people have fantastic auditive memory and comprehension skills, and learn better by recording lessons, or attending events/classes in person&hellip; regardless, the gist of it is that there&rsquo;s not a single universal way to learn, and we all function in different ways.</p>
<h2 id="attention-under-attack">Attention under attack</h2>
<p>To make things worse, nowadays we have big attention issues thanks to having every single device fighting for our attention. It&rsquo;s almost impossible to focus without putting some boundaries and I feel this is where a lot of people fall into that trap, get disappointed/discouraged/anxious and go into bad &ldquo;mental places&rdquo; making things worse. (of course, in a totally unconscious way)</p>
<h2 id="in-general-human-interaction-is-mostly-underestimated">In general, human interaction is mostly underestimated</h2>
<p>And on top of all that, we also underestimate the human part of the whole thing.</p>
<p>I generally feel there&rsquo;s a lot of &ldquo;human interaction&rdquo; type of activities that people tend to underestimate, probably because we miss that teaching isn’t just showing something or doing a demo. It’s paying attention to how people actually learn, respecting their pace, and not assuming the way we learn is the universal way. If we did that more often, half our “communication problems” would probably be alleviated.</p>
<p>Anyway, that’s my rant. Teaching is hard, learning is weird, attention is broken, and humans are complicated. But if we remember that, maybe we’ll stop expecting this process to be easy.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Make your work setup enjoyable</title>
      <link>http://javierdecarli.com/posts/make-your-work-setup-enjoyable/</link>
      <pubDate>Sun, 02 Aug 2026 00:00:00 +0000</pubDate>
      <guid>http://javierdecarli.com/posts/make-your-work-setup-enjoyable/</guid>
      <description>Little details...</description>
      <content:encoded><![CDATA[<p>I&rsquo;m very fortunate of working mostly remote (at least for now) and over the years I kept fine-tuning and improving my work setup. Little changes like a better keayboard, a comfy chair, bigger monitor(s), etc.</p>
<p>It changes a lot having a nice work setup. It changes your day and even how tired you get. We spend a lot of our day on that place (specially if you are a nerd like me) and the more enjoyable our place is, the better.</p>
<p>Spending a bit more on a nice device can change your day.</p>
<p>There you go&hellip; if you were waiting for an excuse to buy a gadget for your &ldquo;work-cave&rdquo; this is it. You&rsquo;re welcome!</p>
]]></content:encoded>
    </item>
    <item>
      <title>Here we go again...</title>
      <link>http://javierdecarli.com/posts/first-post/</link>
      <pubDate>Thu, 30 Jul 2026 00:00:00 +0000</pubDate>
      <guid>http://javierdecarli.com/posts/first-post/</guid>
      <description>(Re)Starting the blog idea once again</description>
      <content:encoded><![CDATA[<p>I&rsquo;ll add other sections as we go, but wanted to get at least one post out the door — once and for all.</p>
<p>This experiment only works if I stay consistent, and consistency requires keeping publishing simple. That&rsquo;s why I chose a very simple <a href="https://gohugo.io/">Hugo</a> template based on the <a href="https://themes.gohugo.io/themes/hugo-papermod/">PaperMod</a> theme. I might write about the process in the future.</p>
<p>Huge thanks to my friend <a href="https://sebasmonia.com">Sebastian</a> for planting the seed to try blogging again. Blogging to me always felt like a more &ldquo;pure&rdquo; way of interacting with the web, it kinda takes me back to when I was a kid getting into computers discovering things like irc, compilers like Turbo Pascal and the beginnings of the internet.</p>
<p>No data collection or cookies — I don&rsquo;t sell anything. I&rsquo;ll keep the site lean while preserving small, subtle design touches (colors, fonts).</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
