Files
skills/public/code-patterns.html
zeekayandHanzo Dev 9e10c1c10e Each llms index points at the other two
hanzoskills.com/llms.txt now opens with the install line, the API
reference index and the company index, so an agent that lands on any
one of the three can find the rest.

robots.txt claimed 537 documents while llms.txt counts 920. The number
is gone from robots.txt; llms.txt derives it.

public/ is regenerated from scripts/site.py, which it had fallen
behind: the copy-prompt menu and agent bar were in the generator and
not in the committed pages. tests/site.mjs passes against the result.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-11 00:27:59 -07:00

437 lines
24 KiB
HTML

<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>code-patterns</title>
<meta name="color-scheme" content="dark">
<style>
/* Committed to one visual world: a dark instrument panel. No light variant —
the dot field and the hairline rules only read on black, and a naive
inversion would wash both out. Every colour is painted explicitly so the page
never borrows a host background. */
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
:root{
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
--font-zen-pixel-square:'Zen Pixel Square',monospace;
--mono:var(--font-zen-mono);
--sans:var(--font-zen-sans);
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
--r:999px; --r-soft:14px;
}
*{box-sizing:border-box}
html{-webkit-text-size-adjust:100%}
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
/* The dot field. A halftone made of one repeating radial-gradient, faded out
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
/* No overflow clip here: the dot field is inset to the box already, and a clip
would cut off the copy-prompt menu. */
.hero{position:relative;border-bottom:1px solid var(--line)}
.hero::before{content:"";position:absolute;inset:0;
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
background-size:7px 7px;
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
pointer-events:none}
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
nav{border-bottom:1px solid var(--line)}
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
justify-content:space-between;align-items:center;gap:1rem}
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--ink);text-decoration:none;
display:inline-flex;align-items:center;gap:.6rem}
.brand i{font-style:normal;color:var(--faint)}
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--soft);text-decoration:none}
nav a.up:hover{color:var(--ink)}
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
h1 em{font-style:normal;color:var(--faint)}
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
line-height:1.2;font-weight:400}
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
.btn.solid:hover{background:#d8d8d4}
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
/* Copy-prompt selector. Each row copies the prompt for its own target. */
.copy{position:relative;display:inline-flex}
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
padding:.4rem;display:flex;flex-direction:column;
box-shadow:0 12px 32px rgba(0,0,0,.75)}
.menu[hidden]{display:none}
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
white-space:nowrap}
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
.mi:hover .mark{color:var(--ink)}
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
letter-spacing:.1em;text-transform:uppercase}
/* Works-with bar: one scrolling row, name and mark per agent. */
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
display:flex;align-items:center}
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
-webkit-overflow-scrolling:touch;
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
.bar::-webkit-scrollbar{display:none}
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
text-decoration:none;background:var(--ground)}
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
.agent .mark{width:.95rem;height:.95rem}
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
p{margin:0 0 1rem;max-width:70ch}
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
li{margin:.22rem 0}
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
text-decoration-color:var(--line-hi)}
a:hover{text-decoration-color:var(--ink)}
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
display:block;overflow-x:auto}
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
.curl{display:block;background:var(--panel);border:1px solid var(--line);
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
white-space:pre;line-height:1.9}
.curl b{color:var(--ink);font-weight:400}
.curl i{font-style:normal;color:var(--faint)}
/* index */
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
#q:focus{outline:none;border-color:var(--soft)}
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
text-transform:uppercase;margin:0 0 2rem}
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
padding-bottom:.45rem}
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
border-radius:var(--r-soft);text-decoration:none}
.row:hover{background:#0a0a0a}
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
color:var(--faint);font-size:.85rem}
footer a{color:var(--soft)}
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
margin:0 0 2rem;font-size:.85rem}
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
border-bottom:1px solid var(--line);padding-bottom:.4rem}
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
.fmap a:hover{text-decoration:underline}
.fmap div{color:var(--faint);line-height:1.5}
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
@media (max-width:640px){
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
.btns{gap:.5rem}
.btn{padding:.75rem 1.15rem;font-size:.68rem}
.copy,.copy .btn{width:100%;justify-content:center}
.menu{left:0;right:0;min-width:0}
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
.strip b{border-right:0;padding-right:0}
.bar{width:100%}
}
</style>
<link rel="alternate" type="text/markdown" href="/code-patterns.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/code-patterns">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/code-patterns.md
Index: https://hanzoskills.com/llms.txt
Corpus: https://hanzoskills.com/all.md
Append .md to any path for the markdown twin. -->
<body>
<nav><div class="in">
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
<a class="up" href="/">All skills</a>
</div></nav>
<div class="wrap">
<h1>code-patterns</h1><p class="lede">Reference guide for detecting AI slop patterns in code including generic variable names, obvious comments, and unnecessary abstractions. Use as reference when reviewing code quality.</p><h1>Code Slop Patterns</h1>
<p>This reference documents common &quot;AI slop&quot; patterns in code that indicate low-quality, AI-generated content that should be cleaned up.</p>
<h2>Table of Contents</h2>
<ul><li>Naming Antipatterns</li><li>Comment Antipatterns</li><li>Structure Antipatterns</li><li>Implementation Antipatterns</li><li>Documentation Antipatterns</li></ul>
<h2>Naming Antipatterns</h2>
<h3>Overly Generic Names</h3>
<p><strong>Bad:</strong> <code>data</code>, <code>result</code>, <code>temp</code>, <code>value</code>, <code>item</code>, <code>thing</code>, <code>obj</code>, <code>info</code></p>
<p>These names appear frequently in AI-generated code and provide no semantic meaning.</p>
<p><strong>Better:</strong> Name things after what they represent:</p>
<ul><li><code>userData</code> → <code>currentUser</code>, <code>userProfile</code>, <code>activeSession</code></li><li><code>result</code> → <code>parsedDocument</code>, <code>sortedItems</code>, <code>validationError</code></li><li><code>temp</code> → <code>formattedDate</code>, <code>normalizedInput</code>, <code>previousValue</code></li></ul>
<h3>Unnecessarily Verbose Names</h3>
<p><strong>Bad:</strong> <code>getUserDataFromDatabaseByUserIdAndReturnResult()</code>, <code>calculateTotalSumOfAllItemPricesInCart()</code></p>
<p><strong>Better:</strong> <code>getUser(userId)</code>, <code>calculateCartTotal()</code></p>
<p>The function signature and context provide enough information.</p>
<h3>Generic Placeholder Patterns</h3>
<p>Watch for repeated use of:</p>
<ul><li><code>foo</code>, <code>bar</code>, <code>baz</code> in production code</li><li><code>test1</code>, <code>test2</code>, <code>test3</code> as function names</li><li><code>MyClass</code>, <code>MyFunction</code>, <code>MyVariable</code> prefixes</li><li><code>Helper</code>, <code>Manager</code>, <code>Handler</code> suffixes without specificity</li></ul>
<h2>Comment Antipatterns</h2>
<h3>Obvious Comments</h3>
<p>Comments that restate what the code clearly does:</p>
<pre><code class="lang-python"># Bad
# Create a user
user = User()
# Increment the counter
counter += 1
# Return the result
return result
# Loop through the items
for item in items:
process(item)</code></pre>
<p><strong>Rule:</strong> If the code is self-documenting, delete the comment.</p>
<h3>Generic TODO Comments</h3>
<pre><code class="lang-python"># Bad
# TODO: Implement this function
# TODO: Add error handling
# TODO: Optimize this code
# TODO: Refactor this
# Better
# TODO(user): Handle case where API returns 429 rate limit
# TODO(user): Profile this loop - suspected O(n²) bottleneck with n&gt;10000</code></pre>
<p>Include WHO should do it, WHAT specifically, and WHY if not obvious.</p>
<h3>Over-Explained Simple Logic</h3>
<pre><code class="lang-python"># Bad
# Check if the user is authenticated by examining the session token
# and verifying it matches our stored tokens in the database
if session.token in valid_tokens:
# If authenticated, proceed with the request
process_request()</code></pre>
<p><strong>Better:</strong> Just write clear code, or if truly complex, explain the business rule, not the syntax.</p>
<h3>Comment Blocks That Announce Sections</h3>
<pre><code class="lang-python"># Bad
########################################
# INITIALIZATION
########################################
########################################
# MAIN PROCESSING LOGIC
########################################</code></pre>
<p><strong>Better:</strong> Use functions or classes to organize code. Comments shouldn&#x27;t be needed to show structure.</p>
<h2>Structure Antipatterns</h2>
<h3>Unnecessary Abstraction Layers</h3>
<pre><code class="lang-python"># Bad - AI-generated overengineering
class UserManagerFactory:
def create_user_manager(self):
return UserManager()
class UserManager:
def get_user_repository(self):
return UserRepository()
class UserRepository:
def get_user(self, user_id):
return db.query(User).filter(User.id == user_id).first()
# Better
def get_user(user_id):
return db.query(User).filter(User.id == user_id).first()</code></pre>
<p><strong>Rule:</strong> Don&#x27;t add abstraction layers until you need them. YAGNI.</p>
<h3>Over-Use of Design Patterns</h3>
<p>Not everything needs to be:</p>
<ul><li>Factory Pattern</li><li>Singleton Pattern</li><li>Observer Pattern</li><li>Strategy Pattern</li><li>Adapter Pattern</li></ul>
<p>Use patterns when they solve real problems, not because you learned about them.</p>
<h3>Generic Error Handling</h3>
<pre><code class="lang-python"># Bad
try:
result = dangerous_operation()
except Exception as e:
print(f&quot;An error occurred: {e}&quot;)
pass # Continue anyway</code></pre>
<p><strong>Better:</strong> Catch specific exceptions and handle them appropriately.</p>
<h3>Empty Catch Blocks</h3>
<pre><code class="lang-python"># Bad
try:
risky_operation()
except:
pass</code></pre>
<p>This is nearly always wrong. If you truly need to ignore an exception, explain why in a comment.</p>
<h2>Implementation Antipatterns</h2>
<h3>Unnecessarily Complex Implementations</h3>
<pre><code class="lang-python"># Bad - AI overthinking simple tasks
def is_even(n):
&quot;&quot;&quot;Check if a number is even using mathematical properties.&quot;&quot;&quot;
return (n / 2) == (n // 2)
# Better
def is_even(n):
return n % 2 == 0</code></pre>
<h3>Premature Optimization</h3>
<pre><code class="lang-python"># Bad - optimizing before profiling
# Using bit manipulation for &quot;performance&quot;
def multiply_by_two(n):
return n &lt;&lt; 1
# Better - clear and correct
def multiply_by_two(n):
return n * 2</code></pre>
<p><strong>Rule:</strong> Clear code first, then optimize based on profiling data.</p>
<h3>Copy-Paste Code Blocks</h3>
<p>Watch for:</p>
<ul><li>Similar functions with slight variations</li><li>Repeated conditional logic</li><li>Duplicated error handling</li></ul>
<p><strong>Better:</strong> Extract common logic into shared functions.</p>
<h3>Magic Numbers Without Explanation</h3>
<pre><code class="lang-python"># Bad
if len(input) &gt; 255:
raise ValueError()
# Better
MAX_INPUT_LENGTH = 255 # Database column limit
if len(input) &gt; MAX_INPUT_LENGTH:
raise ValueError(f&quot;Input exceeds maximum length of {MAX_INPUT_LENGTH}&quot;)</code></pre>
<h2>Documentation Antipatterns</h2>
<h3>Generic Docstrings</h3>
<pre><code class="lang-python"># Bad
def process_data(data):
&quot;&quot;&quot;Process the data.
Args:
data: The data to process
Returns:
The processed data
&quot;&quot;&quot;
pass</code></pre>
<p>This adds zero information. Either document properly or don&#x27;t document at all.</p>
<h3>README Boilerplate</h3>
<p>Watch for:</p>
<ul><li>&quot;This project aims to...&quot;</li><li>&quot;Welcome to our amazing project!&quot;</li><li>Generic installation instructions that don&#x27;t match the actual project</li><li>Placeholder sections never filled in</li><li>Excessive emoji and &quot;inspirational&quot; quotes</li></ul>
<h3>Over-Documented Internal APIs</h3>
<p>Not everything needs exhaustive documentation:</p>
<pre><code class="lang-python"># Bad - Internal helper function
def _format_date(date_obj):
&quot;&quot;&quot;Format a date object into a string.
This function takes a date object and formats it according to
ISO 8601 standards. It is used internally by the DateProcessor
class to ensure consistent date formatting across the application.
Args:
date_obj (datetime): A datetime object representing the date
to be formatted. Must be a valid datetime
instance with timezone information.
Returns:
str: A string representation of the date in ISO 8601 format.
The format includes year, month, day, hour, minute, and
second components with timezone offset.
Raises:
ValueError: If date_obj is None or not a datetime instance.
TypeError: If date_obj is of an incompatible type.
Example:
&gt;&gt;&gt; dt = datetime.now()
&gt;&gt;&gt; _format_date(dt)
&#x27;2024-01-15T14:30:00+00:00&#x27;
Note:
This is an internal function and should not be called directly
by external code. Use the public DateProcessor.format() method
instead.
See Also:
- DateProcessor.format()
- parse_date()
- validate_date()
&quot;&quot;&quot;
return date_obj.isoformat()
# Better for internal helper
def _format_date(date_obj):
&quot;&quot;&quot;Return ISO 8601 formatted string.&quot;&quot;&quot;
return date_obj.isoformat()</code></pre>
<h2>Language-Specific Slop</h2>
<h3>Python</h3>
<ul><li>Unnecessary use of <code>lambda</code> when a function would be clearer</li><li>List comprehensions when a simple loop would be more readable</li><li>Overuse of <code>*args, **kwargs</code> without clear need</li><li>Generic exception catching: <code>except Exception:</code></li></ul>
<h3>JavaScript/TypeScript</h3>
<ul><li>Unnecessary use of arrow functions everywhere</li><li>Over-chaining array methods for simple operations</li><li>Generic <code>any</code> types in TypeScript</li><li>Excessive use of ternary operators for complex logic</li></ul>
<h3>Java</h3>
<ul><li>Excessive getter/setter boilerplate for simple data holders</li><li>Unnecessary use of interfaces with single implementations</li><li>Generic <code>Object</code> types instead of generics</li><li>Over-reliance on inheritance vs composition</li></ul>
<h2>Detection Signals</h2>
<h3>High-Confidence Slop Indicators</h3>
<ol><li>Variable named <code>result</code> that holds different types</li><li>Functions with generic verbs: <code>handleData</code>, <code>processInfo</code>, <code>manageItems</code></li><li>Comments that explain syntax rather than intent</li><li>Every function has a docstring, even trivial ones</li><li>Consistent over-engineering across codebase</li></ol>
<h3>Medium-Confidence Indicators</h3>
<ol><li>Very long function/variable names that include the full context</li><li>Excessive defensive programming (checking for impossible conditions)</li><li>Empty or minimal implementations with &quot;TODO&quot; comments</li><li>Uniform structure across all functions (same patterns everywhere)</li></ol>
<h2>Cleanup Strategies</h2>
<h3>Immediate Actions</h3>
<ol><li>Delete obvious comments</li><li>Rename generic variables in their immediate scope</li><li>Remove empty catch blocks or add proper handling</li><li>Delete unused imports and functions</li></ol>
<h3>Refactoring</h3>
<ol><li>Extract repeated code into functions</li><li>Simplify complex conditionals</li><li>Remove unnecessary abstraction layers</li><li>Replace generic names with domain-specific names</li></ol>
<h3>Testing-Required Changes</h3>
<ol><li>Removing error handling (ensure safe to remove)</li><li>Simplifying algorithms (verify behavior matches)</li><li>Removing &quot;defensive&quot; null checks (ensure they&#x27;re truly unnecessary)</li></ol>
<h2>Context Matters</h2>
<p>Sometimes patterns that look like slop are actually appropriate:</p>
<ul><li><strong>Generic names in small scopes:</strong> <code>i</code>, <code>x</code>, <code>acc</code> in a 3-line function is fine</li><li><strong>Verbose names in public APIs:</strong> Better too clear than too cryptic</li><li><strong>Defensive programming:</strong> In public-facing APIs or critical systems</li><li><strong>Detailed docstrings:</strong> For public libraries and complex algorithms</li><li><strong>Design patterns:</strong> In large codebases where they genuinely help</li></ul>
<p>The key is distinguishing between <strong>intentional engineering decisions</strong> and <strong>mindless pattern repetition</strong>.</p>
<footer>
<div class="fmap">
<div><b>Build</b>
<a href="https://hanzo.app">hanzo.app</a> app builder
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
<div><b>Run</b>
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
<div><b>Account</b>
<a href="https://hanzo.id">hanzo.id</a> sign in
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
<div><b>Company</b>
<a href="https://hanzo.ai">hanzo.ai</a> canonical
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
</div>
<div class="fend"><a href="/code-patterns.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>