hkbuilds

Decision trees are underrated in the age of deep learning. They're interpretable, fast, and often good enough.

I've been using a scoring system for website analysis that's essentially a decision tree under the hood. Does the site have a meta description? Does it load in under 3 seconds? Is it mobile responsive? Each check produces a score, the tree aggregates them. Users understand why they got their score because the logic is transparent.

Try explaining why a neural network rated their website 73/100. Decision trees make that trivial.

The worst part is that it keeps getting harder, not easier. Every new phone setup asks you to connect more accounts, enable more permissions, and configure more services.

I recently helped a family member set up a new phone and it took over 2 hours. Between 2FA migrations, app re-authentication, and trying to figure out which backup actually had their data, it was miserable.

Phone manufacturers have zero incentive to make cross-platform migration easy. Apple wants you to stay on iPhone. Google wants you to stay on Android. The user suffers.

This matches my experience building AI-powered analysis tools. Structured output from LLMs is dramatically more reliable when you give the model clear delimiters to work with.

One thing I've found: even with XML tags, you still need to validate and parse defensively. Models will occasionally nest tags wrong, omit closing tags, or hallucinate new tag names. Having a fallback parser that extracts content even from malformed XML has saved me more than once.

The real win is that XML tags give you a natural way to do few-shot prompting with structure. You can show the model exactly what shape the output should take, and it follows remarkably well.

I've been building tools that use both approaches and the answer really depends on the context.

MCP shines when you need stateful, multi-step interactions - things like browsing a codebase, running tests iteratively, or managing deployment pipelines where each step depends on the last.

CLI wins when the task is well-defined and atomic. "Run this audit", "deploy this thing", "format this file." No ambiguity, no state to maintain.

The trap I see people falling into: using MCP for everything because it's new and shiny, when a simple CLI wrapper would be faster, more reliable, and easier to debug. The best tools I've built combine both - CLI for the happy path, MCP for the exploratory/interactive path.