<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by V. Checha on Medium]]></title>
        <description><![CDATA[Stories by V. Checha on Medium]]></description>
        <link>https://medium.com/@v-checha?source=rss-124b18f17ef1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Mvv58lLWQvx_Ij66nBIi5g.jpeg</url>
            <title>Stories by V. Checha on Medium</title>
            <link>https://medium.com/@v-checha?source=rss-124b18f17ef1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 01:33:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@v-checha/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your store has a new kind of customer, and it doesn’t care about your hero banner]]></title>
            <link>https://v-checha.medium.com/your-store-has-a-new-kind-of-customer-and-it-doesnt-care-about-your-hero-banner-f33d9d2411eb?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/f33d9d2411eb</guid>
            <category><![CDATA[ecommerce]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 14:50:45 GMT</pubDate>
            <atom:updated>2026-11-02T14:51:35.633Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NXkx_FOBYBK9npfn53SWwQ.png" /></figure><blockquote>We built <a href="https://storewalk.ai/">Storewalk.ai</a> to walk your online store the way an AI shopping agent does, so you can see where it gives up before a real one does.</blockquote><p>Somewhere right now, a person is asking an AI assistant to find them a decent pair of running shoes under $120 and buy the blue ones. The assistant visits a few stores, reads what it can, and either completes the purchase or moves on to a competitor without a word. Nobody tells the store which of the two happened.</p><p>That second outcome is the one that bothers us. The agent doesn’t leave a complaint. It doesn’t abandon a cart in a way your analytics will flag. It just reads your page, fails to find a price it can trust, and takes its business elsewhere with the emotional range of a spreadsheet.</p><p>So we built a tool to find out where that happens.</p><h4>What an agent actually needs from your store</h4><p>A human shopper forgives a lot. They’ll squint at a price inside an image, click around until the returns policy turns up, and solve your CAPTCHA while muttering. An agent has the patience of a toddler and the reading habits of a compliance officer.</p><p>To buy something, it has to get through four steps:</p><p>1. <strong>Find.</strong> It has to be allowed in by your robots.txt, discover your products (sitemap, search, structured data), and read pages that don’t need a browser to show their content.<br>2. <strong>Compare.</strong> It needs price, stock, variants, shipping and returns in text it can read and trust. Your carousel, however lovely, it can’t see at all.<br>3. <strong>Buy.</strong> It has to reach checkout as a guest, without a CAPTCHA in the way, with a payment method it can actually use.<br>4. <strong>After the order.</strong> It needs to track the order, start a return and reach support.</p><p>If any step breaks, the purchase stops there. Your conversion funnel has a new leak, and it’s polite enough not to mention it.</p><h4>What Storewalk does</h4><p>You paste your store’s address. In about five minutes, Storewalk reads your store in the order an agent would use it and shows you the first step where an agent would stop.</p><p>You get:</p><p>- <strong>Where an agent would stop.</strong> The first step it couldn’t get past, and what we read there.<br>- <strong>A Ready score out of 100.</strong> It shows the step where each point was lost, so the score explains itself. It still judges you, but it gives reasons.<br>- <strong>What each check read.</strong> For every check, the page or markup it looked at on your store, or what it couldn’t find. You can forward this straight to whoever fixes it.<br>- <strong>A fix list.</strong> Each finding says who fixes it (your developer, a platform setting, an integration) and roughly how much work it is.</p><p>You can also name up to two competitors when you start a scan and see their Ready score next to yours, measured by the same checks. Use this power responsibly. Or don’t, we’re not your manager.</p><p>A passive scan runs 50+ checks. There’s also a second score, Safe, which shows whether your store can tell a real agent from one pretending to be one. That part needs you to verify your domain first, because it tests things we should only test for the owner.</p><h4>The protocols part (we promise it’s short)</h4><p>The way agents buy is being standardised right now, in public, by several groups at once. It’s a bit like watching the plumbing standards for a house get written while people are already moving in.</p><p>One of these is UCP, the Universal Commerce Protocol. A store can publish a profile at `/.well-known/ucp` that tells agents what it supports: checkout, cart, catalog, which payment handlers it accepts, and where its MCP server lives.</p><p>Storewalk reads that profile properly. It validates it against the official schema, checks the services and transports it declares, the payment handlers, and the signing keys. Then it does one more thing: it sends your MCP server exactly one read-only `tools/list` request, to the endpoint your own profile declares, to see whether it answers and which tools it lists. One request per scan, never a tool call. We counted, and we wrote a test that counts too.</p><h4>We show our homework</h4><p>Every full report has a section called “Requests we made”. It lists every request the scan sent, with the method, address, status, timing and, when we didn’t send one, the reason. Query strings and anything that looks like a credential are hidden.</p><p>There’s also a “What the store declares” section, which lays out what your UCP profile says in plain rows, and an “Every check” section where each check opens up to show exactly what it read. If the evidence is JSON, you get it nicely indented, because life is too short for 600 characters of minified JSON-LD.</p><p>The whole thing downloads as a PDF for the people who print things, and as a CSV for the people who put everything in a spreadsheet.</p><h4>Our manners</h4><p>We scan stores whose owners didn’t ask us to. That’s only fair if the crawler behaves, so the limits are written down and enforced in code:</p><p>- robots.txt is read first and obeyed. Two lines in it keep us out entirely, and our /bot page shows you which two.<br>- No more than 2 requests a second to any one host. A scan is quieter than one person browsing your shop.<br>- Each scan has a fixed request budget, and anything past it is refused before it reaches the network.<br>- One user agent, never disguised. We don’t dress the crawler up as Chrome to get past your rules.<br>- A scan never pays, never logs in, never solves a challenge and never uploads a file.<br>- Screenshots and captured page data are deleted after 30 days.</p><p>Our reports tell you which AI crawlers your robots.txt blocks. It would be a bit rich if you couldn’t block ours just as easily.</p><h4>What we won’t pretend</h4><p>When the evidence is too thin to score, there’s no score. The report keeps the space where the number would be and says why.</p><p>When a check can’t run (bot protection answered instead of your shop, a page never loaded), it’s marked as skipped with the reason. We don’t guess the result and fold it into the score behind your back.</p><p>And we’re new. We have no customer logos to show you yet. Everything on our site comes from our own test stores or real scans of real shops. If you were hoping for a wall of famous logos, we’re sorry. You’ll have to make do with the evidence.</p><h4>You can try beta version</h4><p>Run a scan at <a href="https://storewalk.ai/">https://storewalk.ai</a>.</p><p>You don’t need an account to start one. Every full report comes with a free consultation where we go through the findings with you and tell you what to fix first. If you’d rather read first, the <a href="https://storewalk.ai/blog">https://storewalk.ai/blog</a> has technical guides on how agents read pages, the commerce protocols they buy through, and where checkout and payment stop them.</p><p>The name, by the way, comes from retail. A store walk is when you walk your own shop floor the way a customer does, to see what they see. We walk yours the way an AI agent would. It’s less exercise for you, and the agent never asks where the bathroom is.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f33d9d2411eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Document Platform Solo — Here’s What Happened]]></title>
            <link>https://v-checha.medium.com/i-built-a-document-platform-solo-heres-what-happened-ce9a615457ca?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce9a615457ca</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[saas]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Wed, 11 Feb 2026 15:40:21 GMT</pubDate>
            <atom:updated>2026-02-11T15:40:21.989Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/190/1*3C6XYkBfbk__8zxftbJ88A.png" /><figcaption>quixli.io</figcaption></figure><p>Have you ever tried to make a simple document look good and ended up fighting your tool for an hour? You want to drop in a video, maybe a diagram, perhaps a content calendar — and suddenly you’re duct-taping three apps together with screenshots and prayer.</p><p>So I did what any reasonable developer would do. I built my own.</p><p>That’s how Quixli was born — a document platform that actually lets you put <em>*anything*</em> inside a doc. I built it from scratch, and my sleep schedule has opinions about this.</p><h3>The Frustration That Started It All</h3><p>Here’s the thing: existing document tools sit on two extremes. Google Docs is great until you need anything beyond text and tables. Notion is powerful until you’re drowning in databases and toggle hierarchies just to write a project brief. Confluence? Let’s not even go there.</p><p>I kept hitting the same wall: no single tool let me embed a Figma prototype, a Gantt chart, a content calendar, <em>and</em> a PDF viewer in the same document. The workaround was always “paste a screenshot” or “here’s a link, go open another tab.” That felt broken.</p><p>So the question became: <em>what if a document could hold everything your project actually needs?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-vZEVz5Wq3VZpyUtDbpa-g.png" /></figure><h3>What Quixli Actually Does</h3><p>At its core, Quixli is a block-based editor on steroids. There are 40+ block types — and I don’t mean “heading” and “bullet list” (though yes, those are there too).</p><p>You can embed YouTube, Loom, and Vimeo videos that play inline. Drop in a Figma file and interact with it without leaving the doc. Write code with syntax highlighting, render LaTeX math equations, sketch diagrams with Excalidraw, or attach a PDF that viewers can scroll through right there on the page.</p><p>But the blocks I’m most proud of are the ones you won’t find anywhere else. There’s a content calendar where you can plan posts across Instagram, Twitter, and LinkedIn — inside your document. Timeline and Gantt charts for project planning. SWOT analysis and Eisenhower matrix grids for strategic thinking. Tabs, toggles, multi-column layouts, counters — all native, all in one doc.</p><p>Yes, you can embed a Figma prototype right next to your project timeline. No, I’m not kidding.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OKApKgTizQYqI3UWBzbtjg.png" /></figure><p>Collaboration is real-time too — live cursors, simultaneous editing, auto-versioning every 5 minutes so you never lose work. And when you’re ready to share, you get granular control: public links, PIN protection, expiration dates, view limits. You decide exactly who sees what and for how long.</p><p>There’s also Quix collections — bundle multiple pages into a shareable mini-site with auto-generated table of contents. Think of it as turning your docs into a polished guide or knowledge base in one click.</p><h3>The Solo Dev Reality</h3><p>People sometimes ask me why I over-engineered the backend for a “document app.” Here’s the honest answer: when you’re maintaining a growing codebase alone, architecture <em>is</em> your teammate.</p><p>The stack is NestJS and Next.js with PostgreSQL, TipTap as the editor framework, and Yjs for real-time collaboration. I went with Clean Architecture, Domain-Driven Design, and CQRS — not because it’s trendy, but because at 3 AM when something breaks, I need to know exactly where to look.</p><p>The hardest part? Real-time collaboration edge cases. ProseMirror (the engine under TipTap) has <em>opinions</em> about DOM ownership, and Yjs serialization has a habit of surprising you when you least expect it. I’ve debugged more cursor-position-off-by-one issues than I care to admit.</p><p>(My therapist says I should find hobbies that don’t involve WebSocket connections. I’m considering it.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tnLI0O7LM34ySxdycw0qEg.png" /></figure><h3>Give It a Spin</h3><p>I’m still at the very beginning of this journey. There’s a long list of ideas I’m excited to build, and Quixli keeps growing with every week. If you’re curious where it’s heading — jump in now and grow with it.</p><p>Give it a try at <a href="https://quixli.io/">quixli.io</a>. Worst case, you’ll have a really good-looking document.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce9a615457ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coding ≠ Programming]]></title>
            <link>https://v-checha.medium.com/coding-programming-353921590f25?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/353921590f25</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 10:53:29 GMT</pubDate>
            <atom:updated>2026-01-20T10:53:29.491Z</atom:updated>
            <content:encoded><![CDATA[<p>Last week, I watched a junior developer generate an entire REST API in twenty minutes using AI tools. The code was clean, the endpoints were RESTful, the TypeScript types were correct. Then I asked him one question: “What happens when two users update the same record simultaneously?”</p><p>Silence.</p><p>This moment crystallized something I’ve been thinking about for fifteen years as a developer and now, as a department head managing teams: <strong>we’ve confused coding with programming, and AI is making that confusion dangerous.</strong></p><h3>The Distinction That Matters</h3><p><strong>Coding</strong> is translation. You have a solution in your head, and you express it in syntax. It’s knowing that a PostgreSQL upsert looks like INSERT ... ON CONFLICT DO UPDATE. It&#39;s remembering whether JavaScript arrays use splice or slice for removal.</p><p>AI is spectacular at coding. GitHub Copilot can autocomplete your loops. Claude can scaffold your database migrations. ChatGPT can convert your Python script to TypeScript. This is mechanical work, and machines excel at mechanical work.</p><p><strong>Programming</strong> is everything else — and it’s everything that actually matters:</p><ul><li>Understanding <em>what</em> to build before touching a keyboard</li><li>Reasoning about systems that don’t exist yet</li><li>Anticipating failures you’ve never seen</li><li>Making trade-offs that compound over years</li><li>Debugging your mental model, not just your syntax</li></ul><p>When I architect a multi-tenant SaaS system, the coding — writing the actual queries and handlers — might take 20% of my time. The other 80% is programming: deciding whether to use schema-per-tenant or shared tables with tenant IDs, understanding the operational implications of each choice, thinking through what happens when a tenant needs to be migrated or deleted, considering how the choice affects query performance at 10x scale.</p><p>No AI tool makes those decisions for you. And if you let it try, you inherit decisions you don’t understand.</p><h3>The “Vibe Coder” Problem</h3><p>There’s a new archetype emerging in our industry. I call them “vibe coders” — developers who can produce impressive-looking code by vibing with AI tools, but who lack the foundational understanding to maintain, debug, or evolve what they’ve created.</p><p>They can <em>generate</em> a caching layer but can’t explain cache invalidation strategies. They can <em>produce</em> a database schema but don’t understand why certain indexes matter. They can <em>ship</em> features but can’t reason about what happens under load.</p><p>This isn’t the developers’ fault. We’ve created an environment that rewards output over understanding, velocity over sustainability. And AI tools have made it possible to produce output without the traditional forcing function of having to actually understand what you’re building.</p><h3>What AI Tools Actually Accelerate</h3><p>Let me be clear: I use AI tools daily. They’re incredible. But being honest about what they accelerate helps us understand what they can’t replace.</p><p><strong>AI accelerates coding tasks:</strong></p><ul><li>Boilerplate generation</li><li>Syntax lookup</li><li>Code translation between languages</li><li>Pattern implementation you’ve already decided on</li><li>Documentation writing</li><li>Test generation for existing code</li></ul><p><strong>AI cannot accelerate programming tasks:</strong></p><ul><li>Understanding the business domain</li><li>Choosing between architectural approaches</li><li>Debugging conceptual errors in your system design</li><li>Anticipating edge cases specific to your context</li><li>Making trade-offs with incomplete information</li><li>Building mental models of systems</li></ul><p>The dangerous trap is using AI to skip the programming and go straight to coding. You end up with code that works in the demo but fails in production, that passes tests but misses the point, that ships fast but becomes a maintenance nightmare.</p><h3>The Experience Paradox</h3><p>Here’s what’s counterintuitive: AI tools are <em>more</em> valuable to experienced programmers, not less.</p><p>When I use Copilot, I know what I want before it suggests anything. I can evaluate whether its suggestion fits my context. I can spot when it’s generating plausible-looking code that would fail for reasons it doesn’t understand.</p><p>For a junior who hasn’t built the mental models yet, AI suggestions are authoritative-sounding guesses that might work or might be subtly wrong in ways that won’t surface until production.</p><p>This creates a paradox: the developers who benefit most from AI assistance are those who need it least, while those who rely on it most are least equipped to use it well.</p><h3>What Actually Makes Developers Valuable</h3><p>In fifteen years of building production systems, here’s what I’ve learned actually matters:</p><p><strong>1. Systems Thinking</strong> Understanding how components interact, fail, and scale. Knowing that a “simple” feature touches authentication, caching, database writes, and external APIs — and being able to reason about what happens when any of those layers misbehaves.</p><p><strong>2. Failure Mode Intuition</strong> Having seen enough systems break that you instinctively ask “what happens when…?” before writing code. This comes from experience, not from prompts.</p><p><strong>3. Trade-off Navigation</strong> Recognizing that every technical decision is a trade-off and being able to make those trade-offs intentionally based on actual project constraints, not just “best practices” from a blog post.</p><p><strong>4. Domain Understanding</strong> Knowing the business well enough to distinguish between what users say they want and what they actually need. This is why developers who stay on a project long-term often become more valuable than technically brilliant newcomers.</p><p><strong>5. Debugging Mental Models</strong> The most valuable debugging skill isn’t stepping through code — it’s recognizing when your mental model of the system is wrong and updating it.</p><p>None of these skills can be outsourced to AI. All of them take years to develop.</p><h3>The Path Forward</h3><p>I’m not arguing against AI tools — I use them constantly and they make me significantly more productive. I’m arguing for honesty about what they do and don’t provide.</p><p>If you’re a junior developer: use AI tools, but always demand understanding. When Copilot suggests something, ask yourself: <em>why this approach? What are the alternatives? What assumptions is this making?</em> If you can’t answer, you’re coding, not programming.</p><p>If you’re a senior developer: recognize that your experience is more valuable than ever, not less. The market is flooding with people who can generate code. The ability to think through systems, anticipate failures, and make sound trade-offs is becoming rarer, not more common.</p><p>If you’re a team lead: be suspicious of velocity that comes from generating code without understanding. Fast shipping means nothing if you’re accumulating technical debt you can’t even see.</p><h3>The Uncomfortable Truth</h3><p>The uncomfortable truth is this: AI will absolutely replace some coding work. The mechanical translation of requirements into syntax is increasingly automatable.</p><p>But programming — real programming — requires the kind of contextual reasoning, experience-based intuition, and system-level thinking that current AI fundamentally cannot do. And the gap between “code that runs” and “system that works in production for years” is exactly where programming lives.</p><p>The developers who thrive will be those who use AI to accelerate their coding while continuing to invest in their programming. The ones who outsource their thinking to the tools will find, eventually, that they’ve become interchangeable with the tools themselves.</p><p>Coding is what you produce. Programming is what you understand. Only one of those can be automated.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=353921590f25" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Extension Tables]]></title>
            <link>https://v-checha.medium.com/extension-tables-f3e0ada6fce5?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3e0ada6fce5</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[patterns]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Tue, 23 Dec 2025 16:10:43 GMT</pubDate>
            <atom:updated>2025-12-23T16:10:43.754Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>How to add client-specific fields without turning your schema into a maintenance nightmare</blockquote><p>You’re building a SaaS product. Five clients are happily using it. Then Client#3 asks: “Can you add an employee ID field to user profiles? We need it for our HR integration.”</p><p>Simple enough, right? Just add a column to the users table.</p><p>But wait. Client #1 doesn’t need this field. Client #2 wants a <em>different</em> custom field — a department code. Client #4 is asking for insurance group identifiers. Suddenly, your clean users table is growing columns that are NULL for 80% of your records, and your schema is becoming a graveyard of client-specific requirements.</p><p>This is where Extension Tables come in — a pattern I wish I had learned years earlier.</p><h3>The Problem with Traditional Approaches</h3><p>When faced with client-specific data requirements in a multi-tenant system, teams typically reach for one of these solutions:</p><p>Adding nullable columns to existing tables. This seems harmless at first. One column here, another there. But after a year with 20 clients, your users table has 47 columns, and developers need a spreadsheet to remember which columns belong to which client. Migrations become risky because you&#39;re constantly modifying core tables. And those NULL values? They&#39;re eating up space and making your queries less predictable.</p><p>Using a single JSONB column for “extra data.” This approach offers flexibility, but you lose the ability to create proper indexes on specific fields. Query performance degrades as the JSON grows. You can’t enforce data types or constraints at the database level. And good luck writing a JOIN that involves a field buried three levels deep in a JSON structure.</p><p>Entity-Attribute-Value (EAV) pattern. The infamous “just put everything in key-value pairs” approach. It’s flexible, sure, but querying becomes a nightmare of self-joins. Performance tanks as your attribute table grows. And you’ve essentially given up on relational database benefits entirely.</p><p>Separate tables per client. Now you’re maintaining parallel schemas. Your codebase needs conditionals everywhere. Testing becomes a combinatorial explosion. And heaven help the developer who needs to understand how data flows through the system.</p><p>None of these solutions scale well. There’s a better way.</p><h3>What Are Extension Tables?</h3><p>An Extension Table is a separate table that extends a core entity with additional fields, linked by a foreign key. The core table remains clean and universal, while tenant-specific or feature-specific fields live in the extension.</p><p>Here’s the mental model: think of your core users table as the &quot;contract&quot; — the fields that every tenant needs and that your core business logic depends on. The extension table holds everything else — the customizations, the integrations, the &quot;nice to have&quot; fields that vary between clients.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JuofCExf5Emvkoj6_iq5fg.png" /></figure><p>Notice the pattern: every core entity that might need tenant-specific customization gets its own extension table. The relationship is always one-to-one (or one-to-zero), enforced by making the foreign key also the primary key.</p><p>The key insight is this: not every user needs an extension record. If a tenant doesn’t use any custom fields, their users simply don’t have rows in user_extensions. The core table remains uncluttered, and the extension table only contains meaningful data.</p><h3>Implementation: A Complete Example</h3><p>Let’s build this pattern properly with Node.js, TypeScript, and PostgreSQL. I’ll show you the migration, the data access layer, and how to query efficiently.</p><h3>The Migration</h3><pre>// migrations/20241220_create_user_extensions.ts<br>import { Knex } from &#39;knex&#39;;<br><br>export async function up(knex: Knex): Promise&lt;void&gt; {<br>  await knex.schema.createTable(&#39;user_extensions&#39;, (table) =&gt; {<br>    // Primary key is also the foreign key — this enforces 1:1 relationship<br>    // Each user can have at most one extension record<br>    table.uuid(&#39;user_id&#39;).primary()<br>      .references(&#39;id&#39;)<br>      .inTable(&#39;users&#39;)<br>      .onDelete(&#39;CASCADE&#39;);<br>    <br>    // Denormalized tenant_id for query efficiency<br>    // Yes, it&#39;s redundant (users already has tenant_id), but it enables<br>    // efficient partial indexes and avoids JOINs for simple queries<br>    table.string(&#39;tenant_id&#39;, 50).notNullable();<br>    <br>    // Typed columns for fields that need indexing or constraints<br>    // These are fields we KNOW clients will query or filter by<br>    table.string(&#39;employee_id&#39;, 100).nullable();<br>    table.string(&#39;department_code&#39;, 50).nullable();<br>    table.string(&#39;insurance_group&#39;, 100).nullable();<br>    table.string(&#39;external_system_id&#39;, 255).nullable();<br>    <br>    // JSONB for truly dynamic fields that vary per tenant<br>    // This is the escape hatch for unpredictable requirements<br>    table.jsonb(&#39;custom_fields&#39;).notNullable().defaultTo(&#39;{}&#39;);<br>    <br>    // Metadata<br>    table.timestamps(true, true);<br>    <br>    // Index on tenant for efficient tenant-scoped queries<br>    table.index(&#39;tenant_id&#39;);<br>  });<br><br>  // Partial indexes: only index non-null values<br>  // This is crucial for performance — we don&#39;t waste index space<br>  // on the 80% of records where these fields are NULL<br>  <br>  await knex.raw(`<br>    CREATE INDEX idx_user_ext_employee_id <br>    ON user_extensions (tenant_id, employee_id) <br>    WHERE employee_id IS NOT NULL<br>  `);<br><br>  await knex.raw(`<br>    CREATE INDEX idx_user_ext_department <br>    ON user_extensions (tenant_id, department_code) <br>    WHERE department_code IS NOT NULL<br>  `);<br><br>  // GIN index for JSONB queries on custom_fields<br>  // Enables efficient queries like: custom_fields @&gt; &#39;{&quot;region&quot;: &quot;west&quot;}&#39;<br>  await knex.raw(`<br>    CREATE INDEX idx_user_ext_custom_fields <br>    ON user_extensions <br>    USING GIN (custom_fields)<br>  `);<br>}<br><br>export async function down(knex: Knex): Promise&lt;void&gt; {<br>  await knex.schema.dropTableIfExists(&#39;user_extensions&#39;);<br>}</pre><p>Notice several important decisions here. The user_id is both the primary key and foreign key, which enforces a strict one-to-one relationship. We denormalize tenant_id even though it exists on the users table — this enables efficient queries and partial indexes without requiring a JOIN. Partial indexes ensure we only index columns where they actually have values, saving space and improving write performance.</p><h3>The TypeScript Types</h3><pre>// types/user-extensions.ts<br><br>// Configuration that defines which extension fields each tenant uses<br>// This lives in your tenant configuration, not in code<br>export interface TenantExtensionConfig {<br>  // Which typed columns this tenant uses<br>  enabledFields: Array&lt;&#39;employee_id&#39; | &#39;department_code&#39; | &#39;insurance_group&#39; | &#39;external_system_id&#39;&gt;;<br>  <br>  // Schema for custom_fields JSONB — for validation and documentation<br>  customFieldsSchema?: {<br>    [fieldName: string]: {<br>      type: &#39;string&#39; | &#39;number&#39; | &#39;boolean&#39; | &#39;date&#39;;<br>      required?: boolean;<br>      maxLength?: number;<br>      enumValues?: string[];<br>    };<br>  };<br>}<br><br>// The extension record itself<br>export interface UserExtension {<br>  userId: string;<br>  tenantId: string;<br>  employeeId: string | null;<br>  departmentCode: string | null;<br>  insuranceGroup: string | null;<br>  externalSystemId: string | null;<br>  customFields: Record&lt;string, unknown&gt;;<br>  createdAt: Date;<br>  updatedAt: Date;<br>}<br><br>// What we return when fetching a user with extensions<br>// The core user data plus optional extension fields<br>export interface UserWithExtensions {<br>  id: string;<br>  tenantId: string;<br>  email: string;<br>  name: string;<br>  role: string;<br>  createdAt: Date;<br>  updatedAt: Date;<br>  <br>  // Extension fields are optional — not all users have them<br>  extensions?: {<br>    employeeId?: string;<br>    departmentCode?: string;<br>    insuranceGroup?: string;<br>    externalSystemId?: string;<br>    customFields: Record&lt;string, unknown&gt;;<br>  };<br>}</pre><h3>The Repository Layer</h3><p>Here’s where the pattern really shines. We create a clean abstraction that handles the complexity of managing two tables while presenting a simple interface to the rest of the application.</p><pre>// repositories/user.repository.ts<br>import { Knex } from &#39;knex&#39;;<br><br>export class UserRepository {<br>  constructor(<br>    private db: Knex,<br>    private tenantConfig: TenantConfigService<br>  ) {}<br><br>  // Fetch user with extensions in a single efficient query<br>  async findByIdWithExtensions(<br>    tenantId: string, <br>    userId: string<br>  ): Promise&lt;UserWithExtensions | null&gt; {<br>    <br>    const result = await this.db<br>      .select([<br>        &#39;users.id&#39;,<br>        &#39;users.tenant_id&#39;,<br>        &#39;users.email&#39;,<br>        &#39;users.name&#39;,<br>        &#39;users.role&#39;,<br>        &#39;users.created_at&#39;,<br>        &#39;users.updated_at&#39;,<br>        // Extension fields — will be NULL if no extension record exists<br>        &#39;ext.employee_id&#39;,<br>        &#39;ext.department_code&#39;,<br>        &#39;ext.insurance_group&#39;,<br>        &#39;ext.external_system_id&#39;,<br>        &#39;ext.custom_fields&#39;<br>      ])<br>      .from(&#39;users&#39;)<br>      // LEFT JOIN ensures we get the user even if they have no extension<br>      .leftJoin(&#39;user_extensions as ext&#39;, &#39;users.id&#39;, &#39;ext.user_id&#39;)<br>      .where(&#39;users.id&#39;, userId)<br>      .where(&#39;users.tenant_id&#39;, tenantId)<br>      .first();<br><br>    if (!result) return null;<br><br>    return this.mapToUserWithExtensions(result);<br>  }<br><br>  // Create or update extension fields for a user<br>  // Uses UPSERT pattern — insert if not exists, update if exists<br>  async upsertExtensions(<br>    tenantId: string,<br>    userId: string,<br>    extensions: Partial&lt;Omit&lt;UserExtension, &#39;userId&#39; | &#39;tenantId&#39; | &#39;createdAt&#39; | &#39;updatedAt&#39;&gt;&gt;<br>  ): Promise&lt;void&gt; {<br>    <br>    // Validate that tenant is allowed to use these fields<br>    const config = await this.tenantConfig.getExtensionConfig(tenantId);<br>    this.validateExtensionFields(extensions, config);<br><br>    const now = new Date();<br>    <br>    // PostgreSQL UPSERT: INSERT ... ON CONFLICT ... DO UPDATE<br>    await this.db.raw(`<br>      INSERT INTO user_extensions (<br>        user_id, <br>        tenant_id, <br>        employee_id, <br>        department_code, <br>        insurance_group,<br>        external_system_id,<br>        custom_fields,<br>        created_at,<br>        updated_at<br>      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)<br>      ON CONFLICT (user_id) DO UPDATE SET<br>        employee_id = COALESCE(EXCLUDED.employee_id, user_extensions.employee_id),<br>        department_code = COALESCE(EXCLUDED.department_code, user_extensions.department_code),<br>        insurance_group = COALESCE(EXCLUDED.insurance_group, user_extensions.insurance_group),<br>        external_system_id = COALESCE(EXCLUDED.external_system_id, user_extensions.external_system_id),<br>        custom_fields = user_extensions.custom_fields || EXCLUDED.custom_fields,<br>        updated_at = EXCLUDED.updated_at<br>    `, [<br>      userId,<br>      tenantId,<br>      extensions.employeeId ?? null,<br>      extensions.departmentCode ?? null,<br>      extensions.insuranceGroup ?? null,<br>      extensions.externalSystemId ?? null,<br>      JSON.stringify(extensions.customFields ?? {}),<br>      now,<br>      now<br>    ]);<br>  }<br><br>  // Query users by extension field — efficient thanks to partial indexes<br>  async findByEmployeeId(<br>    tenantId: string, <br>    employeeId: string<br>  ): Promise&lt;UserWithExtensions | null&gt; {<br>    <br>    const result = await this.db<br>      .select([<br>        &#39;users.*&#39;,<br>        &#39;ext.employee_id&#39;,<br>        &#39;ext.department_code&#39;,<br>        &#39;ext.insurance_group&#39;,<br>        &#39;ext.external_system_id&#39;,<br>        &#39;ext.custom_fields&#39;<br>      ])<br>      .from(&#39;users&#39;)<br>      .innerJoin(&#39;user_extensions as ext&#39;, &#39;users.id&#39;, &#39;ext.user_id&#39;)<br>      .where(&#39;ext.tenant_id&#39;, tenantId)<br>      .where(&#39;ext.employee_id&#39;, employeeId)<br>      .first();<br><br>    if (!result) return null;<br><br>    return this.mapToUserWithExtensions(result);<br>  }<br><br>  // Query by custom field (JSONB)<br>  async findByCustomField(<br>    tenantId: string,<br>    fieldName: string,<br>    fieldValue: unknown<br>  ): Promise&lt;UserWithExtensions[]&gt; {<br>    <br>    const results = await this.db<br>      .select([&#39;users.*&#39;, &#39;ext.*&#39;])<br>      .from(&#39;users&#39;)<br>      .innerJoin(&#39;user_extensions as ext&#39;, &#39;users.id&#39;, &#39;ext.user_id&#39;)<br>      .where(&#39;ext.tenant_id&#39;, tenantId)<br>      // JSONB containment operator: checks if custom_fields contains the key-value pair<br>      .whereRaw(&#39;ext.custom_fields @&gt; ?&#39;, [<br>        JSON.stringify({ [fieldName]: fieldValue })<br>      ]);<br><br>    return results.map(r =&gt; this.mapToUserWithExtensions(r));<br>  }<br><br>  // Helper: map database row to typed object<br>  private mapToUserWithExtensions(row: any): UserWithExtensions {<br>    const user: UserWithExtensions = {<br>      id: row.id,<br>      tenantId: row.tenant_id,<br>      email: row.email,<br>      name: row.name,<br>      role: row.role,<br>      createdAt: row.created_at,<br>      updatedAt: row.updated_at<br>    };<br><br>    // Only include extensions if the user has any extension data<br>    const hasExtensions = row.employee_id || <br>                          row.department_code || <br>                          row.insurance_group ||<br>                          row.external_system_id ||<br>                          (row.custom_fields &amp;&amp; Object.keys(row.custom_fields).length &gt; 0);<br><br>    if (hasExtensions) {<br>      user.extensions = {<br>        employeeId: row.employee_id ?? undefined,<br>        departmentCode: row.department_code ?? undefined,<br>        insuranceGroup: row.insurance_group ?? undefined,<br>        externalSystemId: row.external_system_id ?? undefined,<br>        customFields: row.custom_fields ?? {}<br>      };<br>    }<br><br>    return user;<br>  }<br><br>  // Helper: validate that tenant can use requested extension fields<br>  private validateExtensionFields(<br>    extensions: Partial&lt;UserExtension&gt;,<br>    config: TenantExtensionConfig<br>  ): void {<br>    if (extensions.employeeId &amp;&amp; !config.enabledFields.includes(&#39;employee_id&#39;)) {<br>      throw new Error(&#39;Tenant is not configured to use employee_id field&#39;);<br>    }<br>    // ... similar validation for other fields<br>  }<br>}</pre><h3>The Hybrid Approach: Typed Columns + JSONB</h3><p>You might have noticed that our extension table uses both typed columns (employee_id, department_code) and a JSONB column (custom_fields). This is intentional and represents the sweet spot between structure and flexibility.</p><p>Use typed columns when the field needs to be indexed for query performance, the field has a predictable type and constraints, or multiple tenants will likely use the same field (even if they call it different things internally).</p><p>Use the JSONB column when the field is truly unique to one tenant, the field is used for storage and retrieval but not for querying, or you need to support fields that aren’t known at development time.</p><p>This hybrid approach gives you the query performance of relational columns where it matters, while maintaining the flexibility to handle unexpected requirements without schema changes.</p><pre>// Example: tenant configuration that defines their extension usage<br>const tenantAlphaConfig: TenantExtensionConfig = {<br>  enabledFields: [&#39;employee_id&#39;, &#39;department_code&#39;],<br>  customFieldsSchema: {<br>    hireDate: { type: &#39;date&#39;, required: false },<br>    emergencyContact: { type: &#39;string&#39;, maxLength: 255 }<br>  }<br>};<br><br>const tenantBetaConfig: TenantExtensionConfig = {<br>  enabledFields: [&#39;insurance_group&#39;],<br>  customFieldsSchema: {<br>    policyNumber: { type: &#39;string&#39;, required: true },<br>    coverageLevel: { type: &#39;string&#39;, enumValues: [&#39;basic&#39;, &#39;premium&#39;, &#39;enterprise&#39;] }<br>  }<br>};</pre><h3>Performance Considerations</h3><p>Let’s address the elephant in the room: doesn’t adding a JOIN hurt performance?</p><p>The short answer is: not meaningfully, if you do it right.</p><p>Partial indexes are your friend. When you create an index with a WHERE clause, PostgreSQL only indexes rows that match the condition. For extension fields that are NULL in 80% of records, this dramatically reduces index size and improves write performance.</p><p>The LEFT JOIN is cheap. Joining on a primary key (which user_id is in the extension table) is extremely efficient. PostgreSQL can use a simple index lookup. In my benchmarks with tables containing millions of rows, the JOIN adds less than 1ms to query time.</p><p>You’re not always JOINing. For operations that don’t need extension data — listing users, authentication, permission checks — you query only the core table. The extension table is only touched when you actually need that data.</p><p>Compare to the alternatives. Adding 20 nullable columns to your users table means every query reads more data from disk, even when you only need core fields. EAV requires multiple self-joins that are far more expensive than a single LEFT JOIN. And JSONB without typed columns can’t use efficient B-tree indexes.</p><p>Here’s a quick benchmark comparison from a real project with 2 million user records:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m6ElO-FCIWgw_YFrI4GpNA.png" /></figure><p>The extension table approach matches or beats alternatives in query performance while maintaining a clean, maintainable schema.</p><h3>Migrating From Nullable Columns to Extension Tables</h3><p>If you’re reading this and thinking “great, but I already have 30 nullable columns in my users table” — don’t worry. Migration is absolutely possible, and I’ve done it on production systems with millions of records. Here’s the battle-tested approach.</p><h3>The Migration Strategy</h3><p>The key principle is zero downtime migration. You don’t want to lock tables or take your system offline. Instead, you’ll run the old and new schemas in parallel during a transition period.</p><pre>// migrations/20241221_step1_create_extension_tables.ts<br>// STEP 1: Create the extension table (non-breaking change)<br><br>import { Knex } from &#39;knex&#39;;<br><br>export async function up(knex: Knex): Promise&lt;void&gt; {<br>  // Create extension table — this doesn&#39;t affect existing code at all<br>  await knex.schema.createTable(&#39;user_extensions&#39;, (table) =&gt; {<br>    table.uuid(&#39;user_id&#39;).primary()<br>      .references(&#39;id&#39;).inTable(&#39;users&#39;).onDelete(&#39;CASCADE&#39;);<br>    table.string(&#39;tenant_id&#39;, 50).notNullable();<br>    <br>    // Columns that currently exist as nullable in users table<br>    table.string(&#39;employee_id&#39;, 100).nullable();<br>    table.string(&#39;department_code&#39;, 50).nullable();<br>    table.string(&#39;insurance_group&#39;, 100).nullable();<br>    table.string(&#39;legacy_field_1&#39;, 255).nullable();  // That field client X needed 2 years ago<br>    table.string(&#39;legacy_field_2&#39;, 255).nullable();  // Another one-off request<br>    <br>    table.jsonb(&#39;custom_fields&#39;).notNullable().defaultTo(&#39;{}&#39;);<br>    table.timestamps(true, true);<br>    <br>    table.index(&#39;tenant_id&#39;);<br>  });<br><br>  // Create partial indexes<br>  await knex.raw(`<br>    CREATE INDEX idx_user_ext_employee_id <br>    ON user_extensions (tenant_id, employee_id) <br>    WHERE employee_id IS NOT NULL<br>  `);<br>}</pre><pre>// migrations/20241221_step2_backfill_extension_data.ts<br>// STEP 2: Copy existing data from nullable columns to extension table<br>// Run this as a background job, not as a blocking migration<br><br>import { Knex } from &#39;knex&#39;;<br><br>export async function up(knex: Knex): Promise&lt;void&gt; {<br>  // Process in batches to avoid locking and memory issues<br>  const BATCH_SIZE = 1000;<br>  let processedCount = 0;<br>  let hasMore = true;<br><br>  while (hasMore) {<br>    // Find users with any extension data that haven&#39;t been migrated yet<br>    const usersToMigrate = await knex(&#39;users&#39;)<br>      .select([&#39;id&#39;, &#39;tenant_id&#39;, &#39;employee_id&#39;, &#39;department_code&#39;, &#39;insurance_group&#39;, &#39;legacy_field_1&#39;, &#39;legacy_field_2&#39;])<br>      .whereNotNull(&#39;employee_id&#39;)<br>      .orWhereNotNull(&#39;department_code&#39;)<br>      .orWhereNotNull(&#39;insurance_group&#39;)<br>      .orWhereNotNull(&#39;legacy_field_1&#39;)<br>      .orWhereNotNull(&#39;legacy_field_2&#39;)<br>      .whereNotExists(<br>        knex.select(&#39;1&#39;).from(&#39;user_extensions&#39;).whereRaw(&#39;user_extensions.user_id = users.id&#39;)<br>      )<br>      .limit(BATCH_SIZE);<br><br>    if (usersToMigrate.length === 0) {<br>      hasMore = false;<br>      continue;<br>    }<br><br>    // Insert into extension table<br>    const extensionRecords = usersToMigrate.map(user =&gt; ({<br>      user_id: user.id,<br>      tenant_id: user.tenant_id,<br>      employee_id: user.employee_id,<br>      department_code: user.department_code,<br>      insurance_group: user.insurance_group,<br>      custom_fields: JSON.stringify({<br>        // Move legacy fields into JSONB — they don&#39;t deserve dedicated columns<br>        ...(user.legacy_field_1 &amp;&amp; { legacyField1: user.legacy_field_1 }),<br>        ...(user.legacy_field_2 &amp;&amp; { legacyField2: user.legacy_field_2 }),<br>      }),<br>      created_at: new Date(),<br>      updated_at: new Date()<br>    }));<br><br>    await knex(&#39;user_extensions&#39;).insert(extensionRecords);<br>    <br>    processedCount += usersToMigrate.length;<br>    console.log(`Migrated ${processedCount} users to extension table...`);<br>  }<br><br>  console.log(`Migration complete. Total users migrated: ${processedCount}`);<br>}</pre><h3>The Dual-Write Period</h3><p>During migration, your application needs to write to both locations. This ensures no data is lost regardless of which code path handles a request.</p><pre>// services/user.service.ts — during migration period<br><br>export class UserService {<br>  async updateUserExtensionFields(<br>    tenantId: string,<br>    userId: string,<br>    fields: ExtensionFields<br>  ): Promise&lt;void&gt; {<br>    <br>    // DUAL WRITE: Update both locations during migration<br>    // This ensures consistency regardless of which read path is used<br>    <br>    await this.db.transaction(async (trx) =&gt; {<br>      // Write to old location (nullable columns on users table)<br>      // This keeps the old code working<br>      await trx(&#39;users&#39;)<br>        .where({ id: userId, tenant_id: tenantId })<br>        .update({<br>          employee_id: fields.employeeId,<br>          department_code: fields.departmentCode,<br>          insurance_group: fields.insuranceGroup,<br>          updated_at: new Date()<br>        });<br><br>      // Write to new location (extension table)<br>      // This prepares for the new code<br>      await trx.raw(`<br>        INSERT INTO user_extensions (user_id, tenant_id, employee_id, department_code, insurance_group, custom_fields, created_at, updated_at)<br>        VALUES (?, ?, ?, ?, ?, ?, NOW(), NOW())<br>        ON CONFLICT (user_id) DO UPDATE SET<br>          employee_id = EXCLUDED.employee_id,<br>          department_code = EXCLUDED.department_code,<br>          insurance_group = EXCLUDED.insurance_group,<br>          updated_at = NOW()<br>      `, [userId, tenantId, fields.employeeId, fields.departmentCode, fields.insuranceGroup, &#39;{}&#39;]);<br>    });<br>  }<br>}</pre><h3>The Cutover</h3><p>Once you’ve verified that all data is migrated and dual-writes are working correctly, you can switch reads to the new extension table. After a stabilization period, remove the old columns.</p><pre>// migrations/20241228_step3_drop_old_columns.ts<br>// STEP 3: Remove nullable columns from users table<br>// Only run this AFTER verifying all reads use extension table<br><br>import { Knex } from &#39;knex&#39;;<br><br>export async function up(knex: Knex): Promise&lt;void&gt; {<br>  // Final cleanup — drop the old columns<br>  await knex.schema.alterTable(&#39;users&#39;, (table) =&gt; {<br>    table.dropColumn(&#39;employee_id&#39;);<br>    table.dropColumn(&#39;department_code&#39;);<br>    table.dropColumn(&#39;insurance_group&#39;);<br>    table.dropColumn(&#39;legacy_field_1&#39;);<br>    table.dropColumn(&#39;legacy_field_2&#39;);<br>  });<br>  <br>  // Your users table is now clean! 🎉<br>}<br><br>// IMPORTANT: Keep the down() migration that recreates columns<br>// In case you need to rollback<br>export async function down(knex: Knex): Promise&lt;void&gt; {<br>  await knex.schema.alterTable(&#39;users&#39;, (table) =&gt; {<br>    table.string(&#39;employee_id&#39;, 100).nullable();<br>    table.string(&#39;department_code&#39;, 50).nullable();<br>    table.string(&#39;insurance_group&#39;, 100).nullable();<br>    table.string(&#39;legacy_field_1&#39;, 255).nullable();<br>    table.string(&#39;legacy_field_2&#39;, 255).nullable();<br>  });<br>}</pre><h3>Migration Checklist</h3><p>Before you start, make sure you have good database backups and a rollback plan. Then deploy the extension table creation without changing any application code. Run the backfill job during low-traffic periods, monitoring database load. Deploy the dual-write code to all application instances and let it run for at least a few days, verifying data consistency between old columns and extension table. Switch read operations to use the extension table while keeping dual-writes active. Monitor for any issues for another week, then finally drop the old columns once you’re confident everything works.</p><p>The whole process typically takes two to four weeks for a production system, depending on your deployment frequency and risk tolerance.</p><h3>When to Use Extension Tables</h3><p>This pattern shines in multi-tenant SaaS applications where different clients need different custom fields. It works beautifully for plugin or module systems where features add entity-specific data, and for integration scenarios where external systems require storing their IDs or metadata.</p><p>However, the pattern might be overkill if all your tenants use exactly the same fields (just use your core table), if you have very few entities to extend (the complexity might not be worth it), or if your “extensions” are actually core business logic that should be properly modeled.</p><h3>Key Takeaways</h3><p>Keep your core tables sacred. They represent your domain model — the essential data that your business logic depends on. Don’t pollute them with optional, client-specific fields.</p><p>Use extension tables for variability. When different clients need different fields, extension tables let you accommodate this without schema sprawl.</p><p>Combine typed columns with JSONB. Use typed columns for fields that need indexing or constraints; use JSONB for truly dynamic data.</p><p>Leverage partial indexes. They’re PostgreSQL’s secret weapon for sparse data — you get index performance without indexing NULL values.</p><p>Validate at the application layer. Since extension fields vary by tenant, your application should enforce which fields each tenant can use.</p><p>The Extension Tables pattern won’t solve every multi-tenant challenge, but for the specific problem of client-specific fields, it’s the most maintainable solution I’ve found. Your future self — the one maintaining this system a year from now with 50 clients — will thank you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3e0ada6fce5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Won’t Replace Developers. But Everyone Will Try First]]></title>
            <link>https://v-checha.medium.com/ai-wont-replace-developers-but-everyone-will-try-first-8903e0baef8d?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/8903e0baef8d</guid>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Tue, 16 Dec 2025 13:07:12 GMT</pubDate>
            <atom:updated>2025-12-16T13:07:12.996Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eVMtcyEayjAFHmh4" /></figure><p><em>Why the next two years will be painful for the industry — and what comes after</em></p><p>Something interesting is happening right now. Clients come to meetings with a new kind of confidence: “Why does it take so long? ChatGPT writes code in seconds.” Some decide they don’t need developers at all anymore — after all, there’s Cursor, Copilot, Claude. Why pay a team when you can “just ask AI”?</p><p>I’ve been a developer for over ten years. I use AI every day — and that’s exactly why I can see where this is heading.</p><h3>What AI Can Actually Do Today</h3><p>Let’s be honest: AI assistants are truly impressive. They can generate working code in seconds. Write a React component. Create an SQL query. Explain a complex concept. For certain tasks, it’s a productivity revolution.</p><p>But there’s a nuance that doesn’t show up in demo videos and marketing materials.</p><p>AI generates code that <em>looks</em> correct. It compiles. It might even work — at first glance. The problems start later: when you need to scale the system, when edge cases appear, when someone tries to hack your product.</p><p>AI doesn’t know your business context. It doesn’t understand how this module will interact with other parts of the system a year from now. It doesn’t think about what happens when instead of ten users, you have ten thousand.</p><h3>The Illusion of Simplicity</h3><p>The most dangerous thing about the current situation is the illusion that programming has become easy.</p><p>A client watches AI generate a page of code in a minute. “See? It’s so simple!” But they don’t see the main thing: 80% of a developer’s work isn’t writing code. It’s understanding requirements, designing architecture, anticipating problems, testing, refactoring, integration, security, performance.</p><p>Code is just the tip of the iceberg. AI helps write that tip faster. But the iceberg hasn’t gone anywhere.</p><p>Imagine someone invented a tool that lets you lay bricks ten times faster. Does that mean anyone can now build a skyscraper? Obviously not. Because construction isn’t about how fast you lay bricks. It’s about foundations, load calculations, utilities, safety.</p><p>The same applies to programming.</p><h3>What I’m Seeing in Practice</h3><p>Over the past year, I’ve been observing a recurring pattern.</p><p>A client decides to “save money” and builds an MVP with “AI + one junior developer” or completely on their own. A few months later, the product seems ready. It even works — under ideal conditions, with ideal data, for one user.</p><p>And then reality hits. The first user enters an emoji in the name field — the system crashes. Someone tries to upload a file larger than 10 MB — the server hangs. Two users simultaneously edit the same document — data gets lost. A competitor finds an SQL injection — and the customer database ends up on the web.</p><p>Then the client comes to a professional team: “We need urgent fixes.” And the team looks at the code and realizes it’s cheaper to rewrite from scratch than to fix this Frankenstein’s monster.</p><h3>Why the Next Two Years Will Be Difficult</h3><p>We’re currently at the peak of the hype. Gartner calls this the “Peak of Inflated Expectations” — when expectations are maximally detached from reality.</p><p>Over the next year or two, we’ll see a wave of failed projects. Startups built on an “AI-first” approach without experienced developers. Enterprise systems created “quickly and cheaply.” Products that couldn’t survive contact with real users.</p><p>It will be painful. For clients — lost money and time. For the industry — damaged trust. For developers — pressure and unrealistic expectations.</p><p>But this is exactly what’s needed for the pendulum to swing back.</p><h3>What Comes After</h3><p>The history of technology shows: after every hype cycle comes sober understanding. It happened with blockchain, with microservices, with NoSQL, with agile.</p><p>AI assistants will find their place — as a powerful tool in a professional’s hands. Not a replacement for developers, but their amplifier. Just as IDEs never replaced programmers, but made them more productive.</p><p>The developer of the future will use AI for routine tasks, for rapid prototyping, for generating boilerplate. But architectural decisions, security, performance, scalability — that will remain with humans. At least for the next several years.</p><h3>What to Do Now</h3><p>If you’re a client — don’t fall for promises of “we’ll build it in a week using AI.” Ask about architecture, about security, about scaling. A cheap project often turns out to be the most expensive one.</p><p>If you’re a developer — learn to use AI effectively, but don’t forget the fundamentals. Architecture, patterns, security — these are things AI still can’t replace. And these are exactly what will be valued when the hype dies down.</p><p>If you’re a manager — protect your team from unrealistic expectations. Explain to the business that AI is a tool, not a magic wand.</p><h3>Conclusion</h3><p>AI is the most powerful tool to appear in software development in the last few decades. But a tool is not a craftsman.</p><p>The hammer didn’t replace the carpenter. The calculator didn’t replace the mathematician. Excel didn’t replace the financial analyst. AI won’t replace the developer.</p><p>But first, everyone will try. And that’s normal. That’s how progress works — through mistakes to understanding.</p><p>Just be prepared for the next two years to be… educational.</p><p><em>The author is a developer from Ukraine. Uses AI daily and considers it a wonderful tool. That’s exactly why he wrote this article.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8903e0baef8d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI не замінить розробників. Але спочатку всі спробують]]></title>
            <link>https://v-checha.medium.com/ai-%D0%BD%D0%B5-%D0%B7%D0%B0%D0%BC%D1%96%D0%BD%D0%B8%D1%82%D1%8C-%D1%80%D0%BE%D0%B7%D1%80%D0%BE%D0%B1%D0%BD%D0%B8%D0%BA%D1%96%D0%B2-%D0%B0%D0%BB%D0%B5-%D1%81%D0%BF%D0%BE%D1%87%D0%B0%D1%82%D0%BA%D1%83-%D0%B2%D1%81%D1%96-%D1%81%D0%BF%D1%80%D0%BE%D0%B1%D1%83%D1%8E%D1%82%D1%8C-65de675a5b7f?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/65de675a5b7f</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Tue, 16 Dec 2025 13:03:17 GMT</pubDate>
            <atom:updated>2025-12-16T13:03:17.290Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XToyC7QdOIFTxNIF" /></figure><p><em>Чому наступні два роки будуть болючими для індустрії — і що буде потім</em></p><p>Зараз відбувається щось цікаве. Клієнти приходять на зустрічі з новою впевненістю: “Чому так довго? ChatGPT пише код за секунди”. Деякі взагалі вирішують, що розробники їм більше не потрібні — адже є Cursor, Copilot, Claude. Навіщо платити команді, якщо можна “просто попросити AI”?</p><p>Я працюю розробником понад десять років. Я використовую AI щодня — і саме тому бачу, куди це все йде.</p><h3>Що насправді вміє AI сьогодні</h3><p>Давайте будемо чесними: AI-асистенти справді вражають. Вони можуть згенерувати робочий код за секунди. Написати компонент на React. Створити SQL-запит. Пояснити складну концепцію. Для певних задач це революція продуктивності.</p><p>Але є нюанс, який не видно з демо-відео та маркетингових матеріалів.</p><p>AI генерує код, який <em>виглядає</em> правильним. Він компілюється. Він навіть може працювати — на перший погляд. Проблеми починаються пізніше: коли потрібно масштабувати систему, коли з’являються edge cases, коли хтось намагається зламати ваш продукт.</p><p>AI не знає контексту вашого бізнесу. Не розуміє, як цей модуль буде взаємодіяти з іншими частинами системи через рік. Не думає про те, що станеться, коли замість десяти користувачів буде десять тисяч.</p><h3>Ілюзія простоти</h3><p>Найнебезпечніше в поточній ситуації — це ілюзія, що програмування стало простим.</p><p>Клієнт бачить, як AI за хвилину генерує сторінку коду. “Бачите? Це ж так просто!” Але він не бачить головного: 80% роботи розробника — це не написання коду. Це розуміння вимог, проєктування архітектури, передбачення проблем, тестування, рефакторинг, інтеграція, безпека, продуктивність.</p><p>Код — це лише верхівка айсберга. AI допомагає писати цю верхівку швидше. Але айсберг нікуди не подівся.</p><p>Уявіть, що хтось винайшов інструмент, який дозволяє класти цеглу вдесятеро швидше. Чи означає це, що тепер будь-хто може побудувати хмарочос? Очевидно, ні. Бо будівництво — це не про швидкість кладки цегли. Це про фундамент, розрахунки навантажень, комунікації, безпеку.</p><p>Так само і з програмуванням.</p><h3>Що я бачу на практиці</h3><p>За останній рік я спостерігаю повторюваний патерн:</p><p>Клієнт вирішує “зекономити” і робить MVP силами “AI + один джуніор” або взагалі самостійно. Через кілька місяців продукт начебто готовий. Він навіть працює — в ідеальних умовах, з ідеальними даними, для одного користувача.</p><p>А потім починається реальність. Перший користувач вводить emoji в поле для імені — система падає. Хтось намагається завантажити файл більше 10 МБ — сервер зависає. Два користувачі одночасно редагують один документ — дані губляться. Конкурент знаходить SQL-ін’єкцію — і база даних клієнтів потрапляє в мережу.</p><p>І тоді клієнт приходить до професійної команди: “Потрібно терміново виправити”. А команда дивиться на код і розуміє, що дешевше переписати з нуля, ніж виправляти цей “франкенштейн”.</p><h3>Чому наступні два роки будуть важкими</h3><p>Ми зараз на піку хайпу. Gartner називає це “Peak of Inflated Expectations” — коли очікування максимально відірвані від реальності.</p><p>Протягом наступних року-двох ми побачимо хвилю провалених проєктів. Стартапи, побудовані на “AI-first” підході без досвідчених розробників. Корпоративні системи, створені “швидко і дешево”. Продукти, які не витримали зіткнення з реальними користувачами.</p><p>Це буде болісно. Для клієнтів — втраченими грошима і часом. Для індустрії — підірваною довірою. Для розробників — тиском і нереалістичними очікуваннями.</p><p>Але саме це потрібно, щоб маятник повернувся назад.</p><h3>Що буде після</h3><p>Історія технологій показує: після кожного хайпу приходить тверезе розуміння. Так було з блокчейном, з мікросервісами, з agile.</p><p>AI-асистенти займуть своє місце — як потужний інструмент у руках професіонала. Не заміна розробника, а його підсилювач. Як IDE колись не замінила програмістів, а зробила їх продуктивнішими.</p><p>Розробник майбутнього буде використовувати AI для рутинних задач, для швидкого прототипування, для генерації бойлерплейту. Але архітектурні рішення, безпека, продуктивність, масштабованість — це залишиться за людьми. Принаймні найближчі роки.</p><h3>Що робити зараз</h3><p>Якщо ви клієнт — не ведіться на обіцянки “зробимо за тиждень за допомогою AI”. Запитуйте про архітектуру, про безпеку, про масштабування. Дешевий проєкт часто виявляється найдорожчим.</p><p>Якщо ви розробник — вчіться використовувати AI ефективно, але не забувайте фундаментальні речі. Архітектура, патерни, безпека — це те, що AI поки не може замінити. І саме це буде цінуватися, коли хайп спаде.</p><p>Якщо ви менеджер — захистіть свою команду від нереалістичних очікувань. Поясніть бізнесу, що AI — це інструмент, а не чарівна паличка.</p><h3>Підсумок</h3><p>AI — це найпотужніший інструмент, який з’явився в розробці за останні десятиліття. Але інструмент — це не майстер.</p><p>Молоток не замінив теслю. Калькулятор не замінив математика. Excel не замінив фінансового аналітика. AI не замінить розробника.</p><p>Але спочатку всі спробують. І це нормально. Так працює прогрес — через помилки до розуміння.</p><p>Просто будьте готові до того, що наступні два роки будуть… повчальними.</p><p><em>Автор — розробник з України. Використовує AI щодня і вважає це чудовим інструментом. Саме тому і написав цю статтю.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65de675a5b7f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[valai: A TypeScript Validation Library Built for the AI Era]]></title>
            <link>https://v-checha.medium.com/building-valai-a-typescript-validation-library-built-for-the-ai-era-64acbedbdc0a?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/64acbedbdc0a</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[validation]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Wed, 10 Dec 2025 16:20:22 GMT</pubDate>
            <atom:updated>2025-12-11T07:44:11.576Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How I built a validation library specifically designed for LLM outputs, and why existing solutions fell short.</em></p><p>If you’ve worked with LLMs like GPT-4 or Claude in production, you know the pain. You ask for JSON, and you get… something that’s <em>almost</em> JSON. Maybe it’s wrapped in markdown. Maybe the keys aren’t quoted. Maybe there’s a trailing comma that breaks everything.</p><p>I got tired of writing the same boilerplate repair code in every project. So I built valai — a TypeScript validation library designed from the ground up for AI/LLM outputs.</p><pre>npm install valai</pre><h3>The Problem with LLM Outputs</h3><p>Let’s be honest: LLMs are terrible at producing valid JSON consistently. Here’s what a typical response might look like</p><pre>Here&#39;s the extracted data:<br><br>```json<br>{<br>  name: &#39;John Doe&#39;,     // unquoted key, single quotes<br>  age: &quot;30&quot;,            // string instead of number<br>  active: true,         // trailing comma<br>}</pre><p>Let me know if you need anything else!</p><pre><br>Try parsing that with `JSON.parse()`. Go ahead, I&#39;ll wait.<br><br>With traditional validation libraries, you&#39;d need to:<br>1. Extract the JSON from markdown<br>2. Fix the single quotes<br>3. Quote the keys<br>4. Remove the trailing comma<br>5. Remove the comments<br>6. Coerce the string &quot;30&quot; to a number<br>7. *Finally* validate the schema<br><br>That&#39;s a lot of code for something that should be simple.<br><br>## Enter valai<br><br>With valai, the same task becomes one line:<br><br>```typescript<br>import { v } from &#39;valai&#39;;<br><br>const UserSchema = v.object({<br>  name: v.string(),<br>  age: v.number(),<br>  active: v.boolean()<br>});<br><br>const result = UserSchema.parseLLM(llmResponse);<br>console.log(result.data); // { name: &#39;John Doe&#39;, age: 30, active: true }</pre><p>That’s it. The parseLLM() method handles all the messy reality of LLM outputs automatically.</p><h3>What Makes valai Different?</h3><h3>1. Built-in JSON Repair</h3><p>The core of valai is a robust JSON repair engine. It handles:</p><p>IssueBeforeAfterMarkdown blocks```json {...} ```{...}Single quotes{&#39;a&#39;: &#39;b&#39;}{&quot;a&quot;: &quot;b&quot;}Unquoted keys{a: 1}{&quot;a&quot;: 1}Trailing commas{&quot;a&quot;: 1,}{&quot;a&quot;: 1}Comments{&quot;a&quot;: 1} // note{&quot;a&quot;: 1}Unclosed brackets{&quot;a&quot;: 1{&quot;a&quot;: 1}</p><p>You can also use the repair functions directly:</p><pre>import { repairJSON, parseAndRepair } from &#39;valai&#39;;<br><br>const result = repairJSON(`{name: &#39;test&#39;, value: 123,}`);<br>console.log(result.data); // { name: &#39;test&#39;, value: 123 }<br>console.log(result.repairs); // List of repairs made</pre><h3>2. Smart Type Coercion</h3><p>In LLM mode, valai automatically coerces types when it makes sense:</p><pre>const schema = v.object({<br>  count: v.number(),<br>  enabled: v.boolean()<br>});<br><br>// LLM returned strings instead of proper types<br>schema.parseLLM(&#39;{&quot;count&quot;: &quot;42&quot;, &quot;enabled&quot;: &quot;true&quot;}&#39;);<br>// Result: { count: 42, enabled: true }</pre><h3>3. AI-Optimized Schema Metadata</h3><p>When working with function calling or structured outputs, you need to tell the LLM what each field means. valai makes this a first-class feature:</p><pre>const ProductSchema = v.object({<br>  name: v.string()<br>    .describe(&#39;The product name as it appears on packaging&#39;)<br>    .examples([&#39;iPhone 15 Pro&#39;, &#39;MacBook Air M3&#39;]),<br><br>  price: v.number()<br>    .min(0)<br>    .describe(&#39;Price in USD, without currency symbol&#39;),<br><br>  category: v.enum([&#39;electronics&#39;, &#39;clothing&#39;, &#39;food&#39;])<br>    .describe(&#39;Primary product category&#39;)<br>});</pre><p>These descriptions and examples are included when you export the schema, helping the LLM understand exactly what you need.</p><h3>4. Multi-Format Export</h3><p>One schema, multiple output formats. Export for any major LLM provider:</p><pre>// OpenAI Function Calling<br>const openAITool = ProductSchema.toOpenAI({<br>  name: &#39;extract_product&#39;,<br>  description: &#39;Extract product information from text&#39;<br>});<br><br>// Anthropic Claude<br>const claudeTool = ProductSchema.toClaude({<br>  name: &#39;extract_product&#39;,<br>  description: &#39;Extract product information from text&#39;<br>});<br><br>// Google Gemini<br>const geminiFunc = ProductSchema.toGemini({<br>  name: &#39;extract_product&#39;,<br>  description: &#39;Extract product information from text&#39;<br>});<br><br>// Standard JSON Schema<br>const jsonSchema = ProductSchema.toJSONSchema();</pre><p>No more manually converting schemas for different providers.</p><h3>The API You Already Know</h3><p>If you’ve used Zod, you already know valai. The schema definition API is intentionally similar:</p><pre>import { v } from &#39;valai&#39;;<br><br>// Primitives<br>v.string()<br>v.number()<br>v.boolean()<br>v.null()<br><br>// String validations<br>v.string().min(1).max(100).email()<br>v.string().url().uuid()<br>v.string().regex(/pattern/)<br><br>// Number validations<br>v.number().int().min(0).max(100)<br>v.number().positive().multipleOf(5)<br><br>// Objects<br>v.object({<br>  name: v.string(),<br>  age: v.number().optional()<br>})<br><br>// Arrays<br>v.array(v.string()).min(1).max(10)<br><br>// Unions and enums<br>v.enum([&#39;pending&#39;, &#39;active&#39;, &#39;completed&#39;])<br>v.union([v.string(), v.number()])<br><br>// Type inference works perfectly<br>type User = v.infer&lt;typeof UserSchema&gt;;</pre><h3>Real-World Example: Building an AI Data Extractor</h3><p>Here’s how I use valai in production to extract structured data from text:</p><pre>import { v } from &#39;valai&#39;;<br>import Anthropic from &#39;@anthropic-ai/sdk&#39;;<br><br>// Define the schema with rich metadata<br>const InvoiceSchema = v.object({<br>  vendor: v.string().describe(&#39;Company or person who issued the invoice&#39;),<br>  invoiceNumber: v.string().describe(&#39;Invoice/receipt number&#39;),<br>  date: v.string().describe(&#39;Invoice date in YYYY-MM-DD format&#39;),<br>  items: v.array(<br>    v.object({<br>      description: v.string().describe(&#39;Item description&#39;),<br>      quantity: v.number().int().min(1).describe(&#39;Quantity purchased&#39;),<br>      unitPrice: v.number().min(0).describe(&#39;Price per unit in USD&#39;),<br>      total: v.number().min(0).describe(&#39;Line item total&#39;)<br>    })<br>  ).describe(&#39;List of items on the invoice&#39;),<br>  subtotal: v.number().describe(&#39;Sum before tax&#39;),<br>  tax: v.number().describe(&#39;Tax amount&#39;),<br>  total: v.number().describe(&#39;Final total amount&#39;)<br>});<br><br>// Create the tool for Claude<br>const extractInvoiceTool = InvoiceSchema.toClaude({<br>  name: &#39;extract_invoice&#39;,<br>  description: &#39;Extract structured data from an invoice image or text&#39;<br>});<br><br>// Use with Claude API<br>const client = new Anthropic();<br><br>async function extractInvoice(invoiceText: string) {<br>  const response = await client.messages.create({<br>    model: &#39;claude-sonnet-4-20250514&#39;,<br>    max_tokens: 1024,<br>    tools: [extractInvoiceTool],<br>    messages: [{<br>      role: &#39;user&#39;,<br>      content: `Extract the invoice data from this text:\n\n${invoiceText}`<br>    }]<br>  });<br><br>  // Find the tool use in the response<br>  const toolUse = response.content.find(block =&gt; block.type === &#39;tool_use&#39;);<br><br>  if (toolUse) {<br>    // Validate and get typed data<br>    const result = InvoiceSchema.safeParse(toolUse.input);<br>    if (result.success) {<br>      return result.data; // Fully typed Invoice object<br>    }<br>  }<br><br>  return null;<br>}</pre><h3>Performance</h3><p>I ran benchmarks comparing valai against other solutions. Here are the highlights:</p><p>Schema Creation:</p><ul><li>Simple schema: 4,628,071 ops/s</li><li>Complex schema: 606,548 ops/s</li></ul><p>String Validations:</p><ul><li>Email: 8,025,967 ops/s</li><li>URL: 8,781,725 ops/s</li></ul><p>LLM-Specific Operations:</p><ul><li>parseLLM() with clean JSON: 1,458,233 ops/s</li><li>parseLLM() with markdown extraction: 1,066,981 ops/s</li><li>JSON repair (GPT-style output): 58,618 ops/s</li></ul><p>The library is fast enough for production use, even with all the repair logic.</p><h3>When to Use valai</h3><p>Use valai if you’re:</p><ul><li>Building applications that consume LLM outputs</li><li>Implementing function calling with OpenAI, Claude, or Gemini</li><li>Parsing user-provided JSON that might be malformed</li><li>Need to export schemas in multiple formats</li></ul><p>Stick with traditional validators if you’re:</p><ul><li>Only validating clean, predictable data</li><li>Don’t need LLM-specific features</li></ul><h3>Getting Started</h3><p>Install the package:</p><pre>npm install valai</pre><p>Basic usage:</p><pre>import { v } from &#39;valai&#39;;<br><br>// Define your schema<br>const schema = v.object({<br>  name: v.string().describe(&#39;User name&#39;),<br>  email: v.string().email(),<br>  age: v.number().int().min(0).optional()<br>});<br><br>// Parse LLM output (with auto-repair)<br>const result = schema.parseLLM(llmResponse);<br><br>// Or strict parsing for clean data<br>const user = schema.parse(cleanData);<br><br>// Export for LLM function calling<br>const tool = schema.toOpenAI({ name: &#39;create_user&#39; });</pre><h3>What’s Next</h3><p>I’m actively developing valai and have plans for:</p><ul><li>Streaming JSON parsing for real-time LLM responses</li><li>More sophisticated type coercion rules</li><li>Integration helpers for popular LLM SDKs</li><li>Schema versioning and migration tools</li></ul><h3>Try It Out</h3><p>The library is open source and available now:</p><ul><li>GitHub: <a href="https://github.com/v-checha/valai">github.com/v-checha/valai</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=64acbedbdc0a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building MCP Servers Without the Boilerplate: Introducing mcpkit]]></title>
            <link>https://v-checha.medium.com/building-mcp-servers-without-the-boilerplate-introducing-mcpkit-b10dbc905a74?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b10dbc905a74</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-protocol]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Wed, 10 Dec 2025 07:49:46 GMT</pubDate>
            <atom:updated>2025-12-10T08:05:20.544Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*Rn-EL8SNA53zLJg6GzCLsQ.png" /></figure><p>TL;DR: <a href="https://github.com/v-checha/mcpkit">GitHub</a></p><p>If you’ve been following the AI tooling space, you’ve probably heard about the Model Context Protocol (MCP). It’s Anthropic’s open standard that lets AI assistants like Claude connect to external data sources and tools. Think of it as a universal adapter that allows your AI to interact with databases, APIs, file systems — pretty much anything you can imagine.</p><p>But here’s the thing: building an MCP server from scratch can be… tedious.</p><p>You need to handle JSON-RPC messages, manage tool schemas, deal with resource templates, set up proper error handling — the list goes on. What should be a fun afternoon project turns into a weekend of wrestling with protocol details.</p><p>That’s exactly why I built mcpkit.</p><h3>What is mcpkit?</h3><p>mcpkit is a TypeScript library that lets you build MCP servers using decorators. Instead of manually wiring up handlers and schemas, you just decorate your methods and let the library handle the rest.</p><p>Here’s what a complete MCP server looks like with mcpkit:</p><pre>import &#39;reflect-metadata&#39;;<br>import { MCPServer, Tool, Param } from &#39;@mcpkit-dev/core&#39;;</pre><pre>@MCPServer({<br>  name: &#39;greeting-server&#39;,<br>  version: &#39;1.0.0&#39;,<br>})<br>class GreetingServer {<br>  @Tool({ description: &#39;Greet someone by name&#39; })<br>  async greet(<br>    @Param({ name: &#39;name&#39;, description: &#39;Name to greet&#39; })<br>    name: string,<br>  ): Promise&lt;string&gt; {<br>    return `Hello, ${name}! Welcome to the world of MCP.`;<br>  }<br>}<br>const server = new GreetingServer();<br>await server.listen();</pre><p>That’s it. No JSON-RPC handling. No schema definitions. No transport setup. Just a decorated class that does exactly what you’d expect.</p><h3>The Problem mcpkit Solves</h3><p>Let me paint you a picture. You want to build a simple weather tool for Claude. With the raw MCP SDK, you’d write something like this:</p><pre>import { McpServer } from &#39;@modelcontextprotocol/sdk/server/mcp.js&#39;;<br>import { StdioServerTransport } from &#39;@modelcontextprotocol/sdk/server/stdio.js&#39;;<br>import { z } from &#39;zod&#39;;</pre><pre>const server = new McpServer({<br>  name: &#39;weather-server&#39;,<br>  version: &#39;1.0.0&#39;,<br>});<br>server.tool(<br>  &#39;getWeather&#39;,<br>  &#39;Get weather for a city&#39;,<br>  {<br>    city: z.string().describe(&#39;City name&#39;),<br>    unit: z.enum([&#39;celsius&#39;, &#39;fahrenheit&#39;]).optional(),<br>  },<br>  async (args) =&gt; {<br>    // Your logic here<br>    return {<br>      content: [{ type: &#39;text&#39;, text: JSON.stringify(result) }],<br>    };<br>  }<br>);<br>const transport = new StdioServerTransport();<br>await server.connect(transport);</pre><p>Not terrible, but notice how the tool definition is spread across multiple arguments? The schema is separate from the handler. The parameter descriptions are buried in Zod calls. And you need to manually format your return values.</p><p>Now look at mcpkit’s approach:</p><pre>@Tool({ description: &#39;Get weather for a city&#39; })<br>async getWeather(<br>  @Param({ name: &#39;city&#39;, description: &#39;City name&#39; })<br>  city: string,<br>  @Param({ name: &#39;unit&#39;, description: &#39;Temperature unit&#39;, optional: true })<br>  unit?: &#39;celsius&#39; | &#39;fahrenheit&#39;,<br>): Promise&lt;WeatherData&gt; {<br>  // Your logic here<br>  return { temperature: 22, conditions: &#39;sunny&#39; };<br>}</pre><p>Everything is co-located. Parameters are decorated right where they’re defined. Return types are just… return types. The framework handles serialization, error formatting, and schema generation automatically.</p><h3>The Four Decorators You Need to Know</h3><p>mcpkit gives you four main decorators that map directly to MCP concepts:</p><h3>1. @Tool — For Actions</h3><p>Tools are things your AI can <em>do</em>. Search a database. Send an email. Calculate something. If it’s an action, it’s a tool.</p><pre>@Tool({<br>  description: &#39;Search for users by name&#39;,<br>  annotations: { readOnlyHint: true }  // Tell the AI this doesn&#39;t modify data<br>})<br>async searchUsers(<br>  @Param({ name: &#39;query&#39;, description: &#39;Search query&#39; })<br>  query: string,<br>): Promise&lt;User[]&gt; {<br>  return this.database.users.search(query);<br>}</pre><h3>2. @Resource — For Data</h3><p>Resources are things your AI can <em>read</em>. Configuration files. Database records. API responses. If it’s data that can be fetched by URI, it’s a resource.</p><pre>// Static resource<br>@Resource({<br>  uri: &#39;config://app/settings&#39;,<br>  name: &#39;App Settings&#39;,<br>  mimeType: &#39;application/json&#39;,<br>})<br>async getSettings() {<br>  return { theme: &#39;dark&#39;, language: &#39;en&#39; };<br>}</pre><pre>// Dynamic resource with URI template<br>@Resource(&#39;users://profile/{userId}&#39;)<br>async getUserProfile(userId: string) {<br>  return this.database.users.findById(userId);<br>}</pre><h3>3. @Prompt — For Templates</h3><p>Prompts are reusable message templates. They’re great for complex interactions that you want to standardize.</p><pre>@Prompt({ description: &#39;Generate a code review for a pull request&#39; })<br>async codeReviewPrompt(<br>  @Param({ name: &#39;prNumber&#39;, description: &#39;Pull request number&#39; })<br>  prNumber: string,<br>) {<br>  const pr = await this.github.getPullRequest(prNumber);</pre><pre>return {<br>    messages: [{<br>      role: &#39;user&#39;,<br>      content: {<br>        type: &#39;text&#39;,<br>        text: `Please review this pull request:<br>Title: ${pr.title}<br>Description: ${pr.description}<br>Changes: ${pr.diff}<br>Focus on code quality, potential bugs, and security issues.`,<br>      },<br>    }],<br>  };<br>}</pre><h3>4. @Param — For Parameters</h3><p>You’ve seen this one already. It decorates method parameters to provide metadata for schema generation.</p><pre>@Param({<br>  name: &#39;temperature&#39;,<br>  description: &#39;Sampling temperature (0-2)&#39;,<br>  schema: z.number().min(0).max(2),  // Optional: explicit Zod schema<br>  optional: true,<br>})<br>temperature?: number</pre><h3>Real-World Example: A Weather Server</h3><p>Let’s build something more substantial. Here’s a weather server that demonstrates all of mcpkit’s features:</p><pre>import &#39;reflect-metadata&#39;;<br>import { MCPServer, Tool, Resource, Prompt, Param } from &#39;@mcpkit-dev/core&#39;;<br>import { z } from &#39;zod&#39;;</pre><pre>interface WeatherData {<br>  temperature: number;<br>  conditions: string;<br>  humidity: number;<br>  location: string;<br>}<br>@MCPServer({<br>  name: &#39;weather-server&#39;,<br>  version: &#39;1.0.0&#39;,<br>  description: &#39;Get weather information worldwide&#39;,<br>})<br>class WeatherServer {<br>  private weatherApi = new WeatherAPI();<br>  // Tool: Get current weather<br>  @Tool({<br>    description: &#39;Get current weather conditions for a city&#39;,<br>    annotations: { readOnlyHint: true },<br>  })<br>  async getWeather(<br>    @Param({ name: &#39;city&#39;, description: &#39;City name (e.g., &quot;London&quot;, &quot;Tokyo&quot;)&#39; })<br>    city: string,<br>    @Param({<br>      name: &#39;unit&#39;,<br>      description: &#39;Temperature unit&#39;,<br>      optional: true,<br>      schema: z.enum([&#39;celsius&#39;, &#39;fahrenheit&#39;]).default(&#39;celsius&#39;),<br>    })<br>    unit?: &#39;celsius&#39; | &#39;fahrenheit&#39;,<br>  ): Promise&lt;WeatherData&gt; {<br>    const weather = await this.weatherApi.getCurrent(city);<br>    if (unit === &#39;fahrenheit&#39;) {<br>      weather.temperature = (weather.temperature * 9/5) + 32;<br>    }<br>    return weather;<br>  }<br>  // Tool: Get forecast (using explicit schema)<br>  @Tool({<br>    description: &#39;Get weather forecast for upcoming days&#39;,<br>    schema: z.object({<br>      city: z.string().describe(&#39;City name&#39;),<br>      days: z.number().min(1).max(7).default(3).describe(&#39;Number of days&#39;),<br>    }),<br>  })<br>  async getForecast(args: { city: string; days: number }) {<br>    return this.weatherApi.getForecast(args.city, args.days);<br>  }<br>  // Resource: Current weather by city<br>  @Resource(&#39;weather://cities/{city}/current&#39;)<br>  async getCityWeatherResource(city: string) {<br>    const weather = await this.weatherApi.getCurrent(city);<br>    return {<br>      contents: [{<br>        uri: `weather://cities/${city}/current`,<br>        mimeType: &#39;application/json&#39;,<br>        text: JSON.stringify(weather, null, 2),<br>      }],<br>    };<br>  }<br>  // Resource: List of available cities<br>  @Resource({<br>    uri: &#39;weather://cities&#39;,<br>    name: &#39;Available Cities&#39;,<br>    description: &#39;List of cities with weather data&#39;,<br>  })<br>  async getCitiesList() {<br>    const cities = await this.weatherApi.getAvailableCities();<br>    return {<br>      contents: [{<br>        uri: &#39;weather://cities&#39;,<br>        mimeType: &#39;application/json&#39;,<br>        text: JSON.stringify(cities),<br>      }],<br>    };<br>  }<br>  // Prompt: Weather report template<br>  @Prompt({ description: &#39;Generate a friendly weather report&#39; })<br>  async weatherReport(<br>    @Param({ name: &#39;city&#39;, description: &#39;City for the report&#39; })<br>    city: string,<br>  ) {<br>    const weather = await this.weatherApi.getCurrent(city);<br>    return {<br>      messages: [{<br>        role: &#39;user&#39;,<br>        content: {<br>          type: &#39;text&#39;,<br>          text: `Write a friendly, conversational weather report for ${weather.location}.<br>Current conditions:<br>- Temperature: ${weather.temperature}°C<br>- Conditions: ${weather.conditions}<br>- Humidity: ${weather.humidity}%<br>Include activity suggestions based on the weather. Keep it brief and engaging.`,<br>        },<br>      }],<br>    };<br>  }<br>}<br>// Start the server<br>const server = new WeatherServer();<br>server.listen().then(() =&gt; {<br>  console.error(&#39;Weather server running on stdio&#39;);<br>});</pre><h3>Two Ways to Define Parameters</h3><p>mcpkit gives you flexibility in how you define tool parameters:</p><h3>Option 1: @Param Decorators (Recommended for most cases)</h3><pre>@Tool({ description: &#39;Send an email&#39; })<br>async sendEmail(<br>  @Param({ name: &#39;to&#39;, description: &#39;Recipient email&#39; })<br>  to: string,<br>  @Param({ name: &#39;subject&#39;, description: &#39;Email subject&#39; })<br>  subject: string,<br>  @Param({ name: &#39;body&#39;, description: &#39;Email body&#39;, optional: true })<br>  body?: string,<br>) {<br>  // Parameters are passed as individual arguments<br>}</pre><h3>Option 2: Explicit Zod Schema (For complex validation)</h3><pre>@Tool({<br>  description: &#39;Create a user&#39;,<br>  schema: z.object({<br>    email: z.string().email(),<br>    age: z.number().min(18).max(120),<br>    role: z.enum([&#39;admin&#39;, &#39;user&#39;, &#39;guest&#39;]),<br>    preferences: z.object({<br>      newsletter: z.boolean(),<br>      theme: z.enum([&#39;light&#39;, &#39;dark&#39;]),<br>    }).optional(),<br>  }),<br>})<br>async createUser(args: CreateUserInput) {<br>  // Args passed as a single object<br>}</pre><p>Use @Param decorators when your parameters are simple and you want clean, co-located code. Use explicit schemas when you need complex validation, nested objects, or want to reuse schemas across multiple tools.</p><h3>Setting Up Your Project</h3><p>Getting started is straightforward:</p><pre>npm install @mcpkit-dev/core @modelcontextprotocol/sdk zod reflect-metadata</pre><p>Your tsconfig.json needs these settings:</p><pre>{<br>  &quot;compilerOptions&quot;: {<br>    &quot;experimentalDecorators&quot;: true,<br>    &quot;emitDecoratorMetadata&quot;: true,<br>    &quot;target&quot;: &quot;ES2022&quot;,<br>    &quot;module&quot;: &quot;NodeNext&quot;,<br>    &quot;moduleResolution&quot;: &quot;NodeNext&quot;<br>  }<br>}</pre><p>Don’t forget to import reflect-metadata at the top of your entry file — it&#39;s what makes the decorator magic work.</p><h3>Connecting to Claude Desktop</h3><p>Once your server is built, connecting it to Claude Desktop is simple. Add it to your Claude config file:</p><p>macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;weather&quot;: {<br>      &quot;command&quot;: &quot;node&quot;,<br>      &quot;args&quot;: [&quot;/path/to/your/server/dist/index.js&quot;]<br>    }<br>  }<br>}</pre><p>Restart Claude Desktop, and your tools, resources, and prompts will be available.</p><h3>Why Decorators?</h3><p>You might be wondering: why decorators? Aren’t they a controversial TypeScript feature?</p><p>Fair question. Here’s my thinking:</p><ol><li>Colocation: Decorators keep metadata right next to the code it describes. No jumping between files or scrolling to find schema definitions.</li><li>Familiarity: If you’ve used NestJS, TypeORM, or Angular, this pattern feels like home. The learning curve is minimal.</li><li>Type Safety: Combined with TypeScript, decorators give you compile-time checking while still allowing runtime introspection.</li><li>Less Boilerplate: The alternative is manual registration, which means more code and more opportunities for things to get out of sync.</li></ol><p>Yes, decorators are technically “stage 2” in the ECMAScript proposal process. But they’ve been stable in TypeScript for years, and the ecosystem has standardized around them for this exact use case.</p><h3>Try It Out</h3><p>The best way to understand mcpkit is to build something with it. Start simple — maybe a tool that fetches data from an API you use daily. Then expand from there.</p><pre>npm install @mcpkit-dev/core @modelcontextprotocol/sdk zod reflect-metadata</pre><p>Check out the <a href="https://github.com/v-checha/mcpkit">GitHub repository</a> for full documentation and examples.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b10dbc905a74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Цю статтю написав AI]]></title>
            <link>https://v-checha.medium.com/%D1%86%D0%B5%D0%B9-%D0%BF%D0%BE%D1%81%D1%82-%D0%BD%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B9-ai-3ef36fa19eba?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ef36fa19eba</guid>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Wed, 26 Nov 2025 08:45:53 GMT</pubDate>
            <atom:updated>2025-11-26T11:03:27.081Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/930/0*JSm-krLDAbXnHoBu.jpeg" /></figure><p><strong>Правда не хочеться читати, коли бачиш що це AI? То чому клієнти вважають, що код який пишуть розробники через AI захочуть читати інші розробники?</strong></p><p>Я пишу програмне забезпечення понад 10років. Я бачив, як тренди приходять і йдуть — від waterfall до agile, від монолітів до мікросервісів, від jQuery до React. Але я ніколи не бачив нічого, що так захоплювало б уяву нетехнічних стейкхолдерів, як AI-асистенти для написання коду.</p><p>Пропозиція звучить спокусливо: ваші розробники стануть на 55% швидшими, ви будете випускати фічі вдвічі швидше, і нарешті зможете робити більше меншими силами. Кожна презентація від GitHub, Amazon та десятка стартапів показує однакові графіки стрімкого зростання. Кожна презентація для ради директорів містить ту саму обіцянку: AI — це срібна куля, яка вирішить усі ваші проблеми з розробкою.</p><p>Є лише одна проблема. Це неправда. І дані це доводять.</p><h3>Брехня про 55%</h3><p>Почнемо з тієї знаменитої заяви GitHub про “55% швидше”. Її повторювали так часто на презентаціях для керівництва, що вона стала догмою. Але чи ви насправді дивилися на дослідження, яке за нею стоїть?</p><p>Ось що зробив GitHub: вони найняли 95 фрілансерів з Upwork, щоб створити простий HTTP-сервер на JavaScript. І все. Одне завдання, одна мова програмування, фрілансери, які ніколи не бачили кодову базу раніше — бо її просто не існувало. Лише 35 розробників завершили кожну умову експерименту. Автори дослідження самі визнали, що вони “не досліджували якість коду” і що “переваги продуктивності можуть відрізнятися залежно від завдань та мов програмування.” (<a href="https://arxiv.org/pdf/2302.06590">Оригінальне дослідження GitHub/Microsoft на arXiv</a>)</p><p>Це фундамент, на якому були обґрунтовані мільярди доларів корпоративних інвестицій в AI. (<a href="https://www.bskiller.com/p/github-says-copilot-makes-you-55">Критичний аналіз заяви про 55%</a>)</p><p>А тепер порівняйте це з тим, що зробила організація METR (Model Evaluation &amp; Threat Research) у 2025 році. Вони провели рандомізоване контрольоване дослідження з 16 досвідченими open-source розробниками, які працювали над реальними завданнями в зрілих репозиторіях — кодових базах, що в середньому містили понад мільйон рядків коду. Ці розробники використовували Cursor Pro з Claude 3.5/3.7 Sonnet — найкращі доступні інструменти.</p><p>Результат? <strong>Розробники працювали на 19% повільніше з AI-допомогою.</strong> (<a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">Дослідження METR: Вимірювання впливу AI початку 2025 року на продуктивність досвідчених Open-Source розробників</a>)</p><p>Але ось що робить це дослідження по-справжньому захоплюючим. Перед початком завдань розробники передбачали, що AI прискорить їх на 24%. Після завершення роботи — після того, як вимірювано працювали повільніше — вони все ще вірили, що AI прискорив їх на 20%. (<a href="https://arxiv.org/abs/2507.09089">Повна дослідницька стаття METR на arXiv</a>)</p><p>Це 43-пунктовий розрив між сприйняттям і реальністю. Розробники настільки переконані, що AI їм допомагає, що не бачать, коли він активно їх сповільнює. (<a href="https://www.theregister.com/2025/07/11/ai_code_tools_slow_down/">Висвітлення в The Register</a>)</p><h3>Код, який ваша команда насправді випускає</h3><p>Поговоримо про те, що відбувається з якістю коду, коли в процес входить AI.</p><p>GitClear проаналізував 211 мільйонів рядків коду з 2020 по 2024 рік у репозиторіях Google, Microsoft, Meta та корпоративних компаній. Те, що вони виявили, має налякати кожного, хто відповідає за підтримку програмного забезпечення (<a href="https://www.gitclear.com/ai_assistant_code_quality_2025_research">Дослідження якості коду AI GitClear 2025</a>):</p><p>Code churn — рядки, які переписуються протягом двох тижнів після написання — подвоївся з моменту масового впровадження AI. Дубльовані блоки коду з п’яти і більше рядків зросли у вісім разів лише протягом 2024 року. Активність рефакторингу впала з 25% змін коду в 2021 році до менш ніж 10% у 2024 році. І 2024 рік став першим роком в історії, коли скопійований код перевищив відрефакторений код. (<a href="https://www.jonas.rs/2025/02/09/report-summary-gitclear-ai-code-quality-research-2025.html">Підсумок та аналіз висновків GitClear</a>)</p><p>Це не невелика зміна. Це фундаментальний переворот у тому, як створюється програмне забезпечення. (<a href="https://devclass.com/2025/02/20/ai-is-eroding-code-quality-states-new-in-depth-report/">Висвітлення в DevClass</a>)</p><p>Коли я переглядаю pull request’и з AI-згенерованим кодом від джуніор-розробників у своїй команді, я бачу одні й ті самі патерни знову і знову: код, який працює, але ігнорує наші існуючі утиліти, реалізації, що дублюють логіку, яка вже є в наших спільних бібліотеках, рішення, які вирішують безпосередню проблему, створюючи три нові. Код виглядає професійно. Він проходить тести. І він робить нашу кодову базу вимірювано гіршою.</p><p>Аналіз LinearB підтверджує те, що я бачу: AI-згенерований код має на 41% вищий показник churn, ніж код, написаний людьми. Ми випускаємо код швидше, але ми також виправляємо його частіше. Чистий ефект на фактичну доставку набагато менший, ніж припускають заголовки — а іноді негативний. (<a href="https://linearb.io/blog/is-github-copilot-worth-it">LinearB: Чи вартий GitHub Copilot своїх грошей?</a>)</p><h3>Безпека: слон у серверній кімнаті</h3><p>Ось число, яке має не давати спати CTO: <strong>40–48% AI-згенерованого коду містить вразливості безпеки.</strong></p><p>Це не спекуляція. Центр безпеки та нових технологій Джорджтаунського університету проаналізував 67 промптів для C-коду на п’яти основних моделях, включаючи GPT-4. Майже половина згенерованих фрагментів містила помилки, які можна виявити через формальну верифікацію — переповнення буфера, пошкодження пам’яті, помилки розіменування. (<a href="https://cset.georgetown.edu/wp-content/uploads/CSET-Cybersecurity-Risks-of-AI-Generated-Code.pdf">Georgetown CSET: Ризики кібербезпеки AI-згенерованого коду</a>)</p><p>Аналіз Veracode 2025 року 80 завдань програмування на понад 100 LLM підтвердив цю тенденцію: 45% AI-згенерованого коду вносить вразливості безпеки, при цьому <strong>Java показує 72% рівень помилок безпеки</strong>, а захист від cross-site scripting провалюється у 86% випадків. (<a href="https://www.businesswire.com/news/home/20250730694951/en/AI-Generated-Code-Poses-Major-Security-Risks-in-Nearly-Half-of-All-Development-Tasks-Veracode-Research-Reveals">Дослідження Veracode про ризики безпеки AI-коду</a>)</p><p>Але ось що робить це по-справжньому небезпечним. Дослідження Стенфордського університету виявило підступну поведінкову закономірність: розробники, які використовують AI-асистентів, писали значно менш безпечний код, ніж контрольні групи, але при цьому були <strong>більш впевнені, що їхній код безпечний</strong>. (<a href="https://arxiv.org/html/2211.03622v3">Стенфордське дослідження: Чи пишуть користувачі більш небезпечний код з AI-асистентами?</a>)</p><p>AI не просто вносить вразливості. Він робить розробників надмірно впевненими в коді, який призведе до злому. (<a href="https://www.darkreading.com/application-security/will-ai-code-generators-overcome-their-insecurities-2025">Висвітлення в Dark Reading</a>)</p><p>А ще є проблема галюцинацій пакетів. Мультиуніверситетське дослідження, що проаналізувало 576 000 зразків коду, виявило, що 19,7% назв пакетів, рекомендованих AI-інструментами, були повністю вигадані. Комерційні моделі на кшталт GPT-4 показали нижчий рівень галюцинацій — близько 5,2%, тоді як open-source моделі досягали 21,7%. Ці постійні галюцинації породили атаки “slopsquatting”, коли зловмисники реєструють вигадані назви пакетів, чекаючи, поки AI-інструменти порекомендують їх нічого не підозрюючим розробникам. (<a href="https://devops.com/ai-generated-code-packages-can-lead-to-slopsquatting-threat/">AI-згенеровані пакети коду ведуть до загрози ‘Slopsquatting’</a>) (<a href="https://www.darkreading.com/application-security/ai-code-tools-widely-hallucinate-packages">Dark Reading: AI-інструменти для коду масово галюцинують пакети</a>)</p><h3>Проблема “майже правильно”</h3><p>Опитування розробників Stack Overflow 2025 року визначило найбільше розчарування розробників у AI-інструментах: 66% вказали на “AI-рішення, які майже правильні, але не зовсім.” (<a href="https://survey.stackoverflow.co/2025/ai">Опитування розробників Stack Overflow 2025 — розділ AI</a>)</p><p>Addy Osmani з Google називає це “проблемою 70%”. AI може швидко створити 70% коду для фічі. Але решта 30% — граничні випадки, інтеграція в продакшен, зміцнення безпеки, оптимізація продуктивності — займає стільки ж часу, скільки й раніше. Іноді більше, бо тепер ви дебажите код, який не писали і не повністю розумієте. (<a href="https://zed.dev/blog/ai-70-problem-addy-osmani">Addy Osmani: Проблема 70% AI</a>)</p><p>Коли я використовую AI для допомоги з фічею в кодовій базі, яку добре знаю, я витрачаю майже стільки ж часу на пояснення контексту AI, скільки витратив би на написання коду самостійно. Який у нас патерн автентифікації? Як ми обробляємо помилки в цьому сервісі? Яка наша конвенція логування? AI нічого цього не знає. Він не може цього знати. Він бачить промпт і генерує правдоподібний код на основі патернів з мільйонів інших кодових баз — жодна з яких не моя.</p><p>Дослідження Qodo виявило, що 65% розробників, які використовують AI для рефакторингу, повідомляють, що асистент “пропускає релевантний контекст”. Серед розробників, які кажуть, що AI погіршив якість їхнього коду, 44% звинувачують саме відсутність контексту. (<a href="https://www.qodo.ai/reports/state-of-ai-code-quality/">Qodo: Стан якості AI-коду в 2025</a>)</p><p>Це фундаментальне обмеження, яке не виправить жоден prompt engineering: AI-інструменти не мають доступу до неявних знань, які досвідчені розробники мають про свої системи. Вони не знають, чому ми прийняли ті рішення, які прийняли. Вони не знають, що ми пробували і відкинули. Вони не знають, що заплановано на наступний квартал. Вони просто генерують код, який виглядає правильним.</p><h3>Чого клієнти не розуміють</h3><p>Я сидів на зустрічах, де стейкхолдери питали, навіщо нам стільки розробників, якщо AI може писати код. Я бачив, як стискають роадмапи на основі припущення, що AI зробить все швидше. Я спостерігав, як скорочують бюджети, бо правління прочитало статтю про AI, що замінює програмістів.</p><p>Ось що показують реальні дослідження:</p><p>Технологічний звіт Bain &amp; Company 2025 року виявив, що хоча дві третини софтверних компаній впровадили AI-інструменти, впровадження серед розробників залишається низьким, а зростання продуктивності в середньому становить лише <strong>10–15%</strong> — значно нижче маркетингових заяв. Гірше того, “часто зекономлений час не перенаправляється на більш цінну роботу” і “навіть ці скромні здобутки не перетворюються на позитивну віддачу.” (<a href="https://www.bain.com/insights/from-pilots-to-payoff-generative-ai-in-software-development-technology-report-2025/">Bain: Від пілотів до прибутку — генеративний AI в розробці ПЗ</a>)</p><p>Звіт DORA від Google — найбільш комплексне дослідження ефективності доставки програмного забезпечення, що опитало понад 39 000 професіоналів — виявив, що впровадження AI насправді погіршує показники доставки. На кожні 25% збільшення використання AI організації бачать зниження пропускної здатності на 1,5% та зниження стабільності доставки на 7,2%. Звіт явно попереджає, що “AI вносить ризик, оскільки розмір пакетів змін, здається, зростає при використанні AI. А більші набори змін — ризикованіші.” (<a href="https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report">Google Cloud: Звіт DORA 2024</a>) (<a href="https://www.infoq.com/news/2024/11/2024-dora-report/">Аналіз звіту DORA 2024 від InfoQ</a>)</p><p>Звіт Harness “Стан доставки програмного забезпечення 2025” виявив, що 67% розробників витрачають БІЛЬШЕ часу на дебаг AI-згенерованого коду, а 68% витрачають більше часу на вирішення вразливостей безпеки, пов’язаних з AI. Для організації з 250 розробниками вони оцінюють втрати продуктивності через дебаг AI-згенерованого коду у 8 мільйонів доларів на рік. (<a href="https://devops.com/survey-ai-tools-are-increasing-amount-of-bad-code-needing-to-be-fixed/">DevOps.com: AI-інструменти збільшують кількість поганого коду</a>)</p><p>Це те, що вам не розповідає ваш постачальник.</p><h3>Бомба уповільненої дії технічного боргу</h3><p>Професор MIT Армандо Солар-Лезама сказав це найкраще: “AI — це як новенька кредитна картка, яка дозволить нам накопичувати технічний борг способами, які раніше були неможливими.” (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: Як AI-згенерований код прискорює технічний борг</a>)</p><p>Я займаюся розробкою достатньо довго, щоб знати, що відбувається, коли ви пріоритизуєте швидкість над стійкістю. Ви швидко випускаєте якийсь час, а потім все сповільнюється. Кожна нова фіча займає більше часу, бо має обходити накопичений безлад. Виправлення багів створюють нові баги. Рефакторинг стає настільки дорогим, що ніхто його не намагається робити. Врешті-решт ви витрачаєте 80% часу на підтримку коду і 20% на створення нових фіч.</p><p>AI драматично прискорює цей цикл. Кін Лейн, з 35 роками в технологіях, зауважив: “Я не думаю, що коли-небудь бачив стільки технічного боргу, створеного за такий короткий період часу за всю свою кар’єру.” (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: Як AI-згенерований код прискорює технічний борг</a>)</p><p>Аналіз Ox Security понад 300 репозиторіїв виявив всепроникні антипатерни в AI-згенерованому коді: <strong>80–90%</strong> демонстрували “уникання рефакторингу” та “фіксацію на підручнику”, тоді як <strong>70–80%</strong> показували порушення принципу DRY. Код виглядає так, ніби його написала “армія джуніорів” — функціональний, але без архітектурного судження. (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: Як AI-згенерований код прискорює технічний борг</a>)</p><p>І це саме те, чим він є. AI генерує код як дуже талановитий джуніор-розробник, який прочитав багато Stack Overflow, але ніколи не підтримував систему п’ять років. Він вирішує безпосередню проблему. Він не думає про те, що буде далі.</p><h3>Розрив довіри зростає</h3><p>З’явилася тривожна розбіжність: впровадження AI-інструментів для кодування зросло з 70% (2023) до 84% (2025), тоді як довіра рухається в протилежному напрямку. Опитування Stack Overflow 2025 року виявило, що <strong>46% розробників активно не довіряють точності AI-результатів</strong>, лише <strong>33% висловлюють довіру</strong>, і лише <strong>3% повідомляють про “високу довіру”</strong>. (<a href="https://survey.stackoverflow.co/2025/ai">Опитування Stack Overflow 2025 — дані про довіру до AI</a>) (<a href="https://www.computing.co.uk/news/2025/stack-overflow-developer-survey-identifies-ai-trust-gap">Computing UK: Опитування Stack Overflow виявило розрив довіри до AI</a>)</p><p>Опитування JetBrains 2024 року виявило небезпечну суперечність: <strong>76% розробників вірять, що AI створює більш безпечний код, ніж люди</strong>, однак <strong>59% мають занепокоєння щодо безпеки</strong> AI-згенерованого коду. Ця помилкова впевненість стикається з академічними висновками, що розробники з AI-допомогою пишуть менш безпечний код, водночас відчуваючи більшу впевненість у ньому. (<a href="https://www.prosus.com/our-insights/portfolio-stories/2024/stack-overflow-2024-developer-survey">Prosus: Аналіз опитування розробників Stack Overflow 2024</a>)</p><h3>Де AI насправді допомагає</h3><p>Я не кажу, що AI-інструменти для кодування марні. Я використовую їх щодня. Але я використовую їх для конкретних речей:</p><p>Генерація бойлерплейту. Коли мені потрібен новий React-компонент зі стандартними імпортами, налаштуванням хуків і TypeScript-інтерфейсами, AI економить мені п’ять хвилин набору. Каркас юніт-тестів. AI справді добрий у генерації тест-кейсів для простих функцій. Вивчення нових фреймворків. Коли я досліджую бібліотеку, яку раніше не використовував, AI допомагає мені зрозуміти патерни швидше, ніж читання документації. Документація. Перші чернетки JSDoc-коментарів, README-файлів та API-документації швидко збираються з допомогою AI.</p><p>Це реальні переваги. Але це інкрементальні покращення конкретних завдань, а не трансформація, яку продають.</p><p>Де AI постійно провалюється: складна бізнес-логіка, код критичний для безпеки, оптимізація продуктивності, архітектурні рішення, все, що вимагає розуміння того, чому код існує, а не що код робить. Дослідження METR виявило, що досвідчені розробники на знайомих кодових базах — саме ситуація, де глибокі знання найважливіші — бачили найбільше сповільнення від AI-допомоги. (<a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">Дослідження METR</a>)</p><p>Польове дослідження 4 867 розробників у корпоративних середовищах виявило більш нюансовані результати: джуніор-розробники бачили покращення на 21–40% на незнайомих завданнях, тоді як сеньйор-розробники та розробники з великим стажем не показали статистично значущих здобутків продуктивності. (<a href="https://itrevolution.com/articles/new-research-reveals-ai-coding-assistants-boost-developer-productivity-by-26-what-it-leaders-need-to-know/">IT Revolution: AI-асистенти для кодування підвищують продуктивність розробників на 26%</a>)</p><h3>Повідомлення для клієнтів</h3><p>Якщо ви читаєте це як людина, яка приймає рішення щодо бюджетів на розробку, термінів або розмірів команд, ось що вам потрібно зрозуміти:</p><p>AI-асистенти для кодування — це інструменти, а не магія. Вони допомагають з деякими завданнями і шкодять з іншими. Здобутки продуктивності на 55%, які ви бачили в презентаціях постачальників, базуються на штучних бенчмарках, які не відображають реальну розробку. Незалежні дослідження показують, що для досвідчених розробників, які працюють над зрілими кодовими базами, AI може насправді сповільнювати роботу.</p><p>Код, що виходить з AI-інструментів, має вимірювані проблеми якості. Він більше змінюється, більше дублюється, містить більше вразливостей. Це не теоретичні занепокоєння — вони задокументовані на сотнях мільйонів рядків продакшен-коду. Технічний борг, який ваші команди накопичують зараз, буде сповільнювати їх роками.</p><p>Коли ви стискаєте терміни на основі припущень про AI, ви не отримуєте фічі швидше. Ви отримуєте технічний борг швидше. Коли ви скорочуєте розміри команд, очікуючи, що AI візьме на себе навантаження, ви не економите гроші. Ви зменшуєте досвідчене судження, яке утримує AI-згенерований код від перетворення на проблему.</p><p>Стійкий підхід — ставитися до AI як до того, чим він насправді є: здібного, але ненадійного асистента, як талановитого інтерна, який може виконати рутинну роботу, але чий результат потребує ретельного перегляду. Вимірюйте успіх стабільністю доставки та якістю коду, а не кількістю випущених рядків AI-згенерованого коду. Підтримуйте реалістичні очікування. І слухайте своїх розробників, коли вони кажуть вам, що інструменти не відповідають хайпу.</p><p>Іпек Озкая з Carnegie Mellon пропонує критичне керівництво: “Якщо робочі процеси розробки програмного забезпечення з AI-підтримкою не спроектовані для запобігання, розпізнавання, виправлення та обліку цих помилок, вони, ймовірно, стануть кошмарами в майбутньому, накопичуючи некерований технічний борг.” (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: Як AI-згенерований код прискорює технічний борг</a>)</p><h3>Повідомлення для розробників</h3><p>Для моїх колег-розробників: довіряйте своїй інтуїції. Якщо AI-згенерований код здається неправильним, він, ймовірно, такий і є. Якщо ви витрачаєте більше часу на перегляд і виправлення AI-результатів, ніж витратили б на написання коду самостійно, це реальна ціна — навіть якщо вона так не відчувається.</p><p>Дослідження показують щось цікаве: ми постійно переоцінюємо, наскільки AI нам допомагає. Ми передбачаємо, що він нас прискорить, і навіть коли цього не відбувається, ми віримо, що так і було. Цей розрив сприйняття реальний і задокументований. Будьте скептичні до власної оцінки. (<a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">Дослідження METR про розрив сприйняття</a>)</p><p>Використовуйте AI там, де він справді допомагає: бойлерплейт, тести, документація, навчання. Будьте обережні там, де він не допомагає: складна логіка, безпека, архітектура. І заперечуйте, коли стейкхолдери мають нереалістичні очікування, засновані на маркетингових матеріалах, а не на вимірюваних результатах.</p><p>Інструменти стануть кращими. Але зараз розрив між тим, що обіцяють, і тим, що доставляють, значний. Ваша робота — випускати якісне програмне забезпечення, яке працює, а не валідувати заяви постачальників про революційні здобутки продуктивності.</p><h3>Підсумок</h3><p>Правда ж не хочеться читати документ, коли бачиш, що він написаний AI?</p><p>А тепер уявіть читання тисяч рядків такого коду. Код, який виглядає професійно, але не розуміє вашу архітектуру. Код, який вирішує безпосередні проблеми, створюючи майбутні. Код, який проходить тести, але містить приховані баги, які проявляться в продакшені.</p><p>Ось чим наповнюється ваша кодова база. І дослідження це чітко показують: подвоєний code churn, восьмиразове збільшення дублювання, 40–48% рівень вразливостей безпеки, 19% сповільнення для досвідчених розробників.</p><p>AI в розробці програмного забезпечення — це не срібна куля. Це навіть не звичайна куля. Це інструмент з конкретними випадками використання, значними обмеженнями та витратами, які не показують у презентаціях постачальників.</p><p>Чим швидше ми перестанемо вдавати інакше, тим швидше зможемо ефективно використовувати ці інструменти.</p><h3>Підсумок посилань</h3><p>Для зручності доступу, ось всі ключові дослідницькі джерела, цитовані в цій статті:</p><p><strong>Дослідження продуктивності:</strong></p><ul><li><a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">Дослідження METR 2025 RCT (19% сповільнення)</a></li><li><a href="https://arxiv.org/pdf/2302.06590">Оригінальне дослідження GitHub/Microsoft 55%</a></li><li><a href="https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report">Звіт DORA 2024</a></li><li><a href="https://www.bain.com/insights/from-pilots-to-payoff-generative-ai-in-software-development-technology-report-2025/">Технологічний звіт Bain &amp; Company 2025</a></li></ul><p><strong>Дослідження якості коду:</strong></p><ul><li><a href="https://www.gitclear.com/ai_assistant_code_quality_2025_research">GitClear AI Code Quality 2025</a></li><li><a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: Аналіз технічного боргу</a></li><li><a href="https://linearb.io/blog/is-github-copilot-worth-it">LinearB Copilot ROI аналіз</a></li></ul><p><strong>Дослідження безпеки:</strong></p><ul><li><a href="https://cset.georgetown.edu/wp-content/uploads/CSET-Cybersecurity-Risks-of-AI-Generated-Code.pdf">Georgetown CSET дослідження безпеки</a></li><li><a href="https://www.businesswire.com/news/home/20250730694951/en/AI-Generated-Code-Poses-Major-Security-Risks-in-Nearly-Half-of-All-Development-Tasks-Veracode-Research-Reveals">Veracode 2025 AI Code Security</a></li><li><a href="https://arxiv.org/html/2211.03622v3">Stanford: Чи пишуть користувачі більш небезпечний код з AI?</a></li></ul><p><strong>Опитування розробників:</strong></p><ul><li><a href="https://survey.stackoverflow.co/2025/ai">Stack Overflow 2025 Developer Survey — AI</a></li><li><a href="https://www.qodo.ai/reports/state-of-ai-code-quality/">Qodo State of AI Code Quality</a></li><li><a href="https://zed.dev/blog/ai-70-problem-addy-osmani">Addy Osmani: Проблема 70%</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ef36fa19eba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Coding Assistants: The Gap Between Marketing Hype and Developer Reality]]></title>
            <link>https://v-checha.medium.com/this-post-was-written-by-ai-b0377549753a?source=rss-124b18f17ef1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0377549753a</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[V. Checha]]></dc:creator>
            <pubDate>Wed, 26 Nov 2025 08:42:11 GMT</pubDate>
            <atom:updated>2025-12-01T07:23:38.673Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zHA0rHa3wVAIxtyj.jpeg" /></figure><p><strong>Doesn’t feel great reading that, does it? So why do clients think that code written by developers through AI will be something other developers want to read?</strong></p><p>I’ve been writing software for over 10 years. I’ve seen trends come and go — from waterfall to agile, from monoliths to microservices, from jQuery to React. But I’ve never seen anything capture the imagination of non-technical stakeholders quite like AI coding assistants.</p><p>The pitch is seductive: your developers will be 55% faster, you’ll ship features in half the time, and you can finally do more with less. Every sales deck from GitHub, Amazon, and a dozen startups shows the same hockey-stick graphs. Every boardroom presentation includes the same promise: AI is the silver bullet that will solve all your development bottlenecks.</p><p>There’s just one problem. It’s not true. And the data proves it.</p><h3>The 55% Lie</h3><p>Let’s start with that famous “55% faster” claim from GitHub. It’s been repeated so often in executive presentations that it’s become gospel. But have you actually looked at the study behind it?</p><p>Here’s what GitHub did: they hired 95 freelancers from Upwork to build a simple HTTP server in JavaScript. That’s it. One task, one language, freelancers who had never seen the codebase before because there was no codebase. Only 35 developers completed each condition. The study authors themselves admitted they “did not examine code quality” and that “productivity benefits may vary across tasks and languages.” (<a href="https://arxiv.org/pdf/2302.06590">Original GitHub/Microsoft Study on arXiv</a>)</p><p>This is the foundation upon which billions of dollars in enterprise AI investments have been justified. (<a href="https://www.bskiller.com/p/github-says-copilot-makes-you-55">Critical analysis of the 55% claim</a>)</p><p>Now compare this to what METR (Model Evaluation &amp; Threat Research) did in 2025. They ran a randomized controlled trial with 16 experienced open-source developers working on real tasks in mature repositories — codebases averaging over one million lines of code. These developers used Cursor Pro with Claude 3.5/3.7 Sonnet, the best tools available.</p><p>The result? <strong>Developers were 19% slower with AI assistance.</strong> (<a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">METR Study: Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity</a>)</p><p>But here’s what makes this study genuinely fascinating. Before starting their tasks, developers predicted AI would speed them up by 24%. After completing their work — after being measurably slower — they still believed AI had made them 20% faster. (<a href="https://arxiv.org/abs/2507.09089">Full METR research paper on arXiv</a>)</p><p>That’s a 43-point gap between perception and reality. Developers are so convinced AI helps them that they can’t see when it’s actively slowing them down. (<a href="https://www.theregister.com/2025/07/11/ai_code_tools_slow_down/">Coverage in The Register</a>)</p><h3>The Code Your Team Is Actually Shipping</h3><p>Let’s talk about what happens to code quality when AI enters the picture.</p><p>GitClear analyzed 211 million lines of code from 2020 to 2024 across repositories from Google, Microsoft, Meta, and enterprise companies. What they found should terrify anyone responsible for maintaining software (<a href="https://www.gitclear.com/ai_assistant_code_quality_2025_research">GitClear AI Code Quality 2025 Research</a>):</p><p>Code churn — lines that get revised within two weeks of being written — has doubled since AI adoption became widespread. Duplicate code blocks of five or more lines have increased eight-fold during 2024 alone. Refactoring activity has collapsed from 25% of code changes in 2021 to less than 10% in 2024. And 2024 marked the first year in recorded history where copy-pasted code exceeded refactored code. (<a href="https://www.jonas.rs/2025/02/09/report-summary-gitclear-ai-code-quality-research-2025.html">Summary and analysis of GitClear findings</a>)</p><p>This isn’t a small shift. This is a fundamental reversal in how software gets built. (<a href="https://devclass.com/2025/02/20/ai-is-eroding-code-quality-states-new-in-depth-report/">Coverage in DevClass</a>)</p><p>When I review AI-generated pull requests from junior developers on my team, I see the same patterns repeatedly: code that works but ignores our existing utilities, implementations that duplicate logic we already have in shared libraries, solutions that solve the immediate problem while creating three new ones. The code looks professional. It passes tests. And it makes our codebase measurably worse.</p><p>LinearB’s analysis confirms what I’m seeing: AI-generated code has a 41% higher churn rate than human-written code. We’re shipping code faster, but we’re also fixing it more often. The net effect on actual delivery is much smaller than the headlines suggest — and sometimes negative. (<a href="https://linearb.io/blog/is-github-copilot-worth-it">LinearB: Is GitHub Copilot Worth It?</a>)</p><h3>Security: The Elephant in the Server Room</h3><p>Here’s a number that should keep CTOs awake at night: <strong>40–48% of AI-generated code contains security vulnerabilities.</strong></p><p>This isn’t speculation. Georgetown University’s Center for Security and Emerging Technology analyzed 67 C code prompts across five major models including GPT-4. Nearly half of the generated snippets contained bugs that formal verification could detect — buffer overflows, memory corruption, dereference failures. (<a href="https://cset.georgetown.edu/wp-content/uploads/CSET-Cybersecurity-Risks-of-AI-Generated-Code.pdf">Georgetown CSET: Cybersecurity Risks of AI-Generated Code</a>)</p><p>Veracode’s 2025 analysis of 80 coding tasks across 100+ LLMs confirmed the pattern: 45% of AI-generated code introduces security vulnerabilities, with <strong>Java showing a 72% security failure rate</strong> and cross-site scripting defenses failing 86% of the time. (<a href="https://www.businesswire.com/news/home/20250730694951/en/AI-Generated-Code-Poses-Major-Security-Risks-in-Nearly-Half-of-All-Development-Tasks-Veracode-Research-Reveals">Veracode Research on AI Code Security Risks</a>)</p><p>But here’s what makes this genuinely dangerous. A Stanford user study revealed an insidious behavioral pattern: developers using AI assistants wrote significantly less secure code than control groups, yet were <strong>more likely to believe their code was secure</strong>. (<a href="https://arxiv.org/html/2211.03622v3">Stanford Study: Do Users Write More Insecure Code with AI Assistants?</a>)</p><p>The AI isn’t just introducing vulnerabilities. It’s making developers overconfident about code that will get them breached. (<a href="https://www.darkreading.com/application-security/will-ai-code-generators-overcome-their-insecurities-2025">Coverage in Dark Reading</a>)</p><p>And then there’s the package hallucination problem. A multi-university study analyzing 576,000 code samples found that 19.7% of package names recommended by AI tools were completely fabricated. Commercial models like GPT-4 showed lower hallucination rates around 5.2%, while open-source models reached 21.7%. These persistent hallucinations have spawned “slopsquatting” attacks where malicious actors register the invented package names, waiting for AI tools to recommend them to unsuspecting developers. (<a href="https://devops.com/ai-generated-code-packages-can-lead-to-slopsquatting-threat/">AI-Generated Code Packages Lead to ‘Slopsquatting’ Threat</a>) (<a href="https://www.darkreading.com/application-security/ai-code-tools-widely-hallucinate-packages">Dark Reading: AI Code Tools Widely Hallucinate Packages</a>)</p><h3>The “Almost Right” Problem</h3><p>Stack Overflow’s 2025 Developer Survey identified the single largest frustration developers have with AI tools: 66% cited “AI solutions that are almost right, but not quite.” (<a href="https://survey.stackoverflow.co/2025/ai">Stack Overflow 2025 Developer Survey — AI Section</a>)</p><p>Google’s Addy Osmani calls this the “70% problem.” AI can rapidly produce 70% of the code for a feature. But the remaining 30% — the edge cases, the production integration, the security hardening, the performance optimization — takes just as long as it ever did. Sometimes longer, because now you’re debugging code you didn’t write and don’t fully understand. (<a href="https://zed.dev/blog/ai-70-problem-addy-osmani">Addy Osmani: AI’s 70% Problem</a>)</p><p>When I use AI to help with a feature in a codebase I know well, I spend almost as much time explaining context to the AI as I would have spent just writing the code. What’s our authentication pattern? How do we handle errors in this service? What’s our logging convention? The AI doesn’t know any of this. It can’t know it. It sees a prompt and generates plausible-looking code based on patterns from millions of other codebases — none of which are mine.</p><p>Qodo Research found that 65% of developers using AI for refactoring report the assistant “misses relevant context.” Among developers who say AI degraded their code quality, 44% blame missing context specifically. (<a href="https://www.qodo.ai/reports/state-of-ai-code-quality/">Qodo: State of AI Code Quality in 2025</a>)</p><p>This is the fundamental limitation that no amount of prompt engineering fixes: AI tools have no access to the tacit knowledge that experienced developers carry about their systems. They don’t know why we made the decisions we made. They don’t know what we tried and rejected. They don’t know what’s coming in next quarter’s roadmap. They just generate code that looks right.</p><h3>What Clients Don’t Understand</h3><p>I’ve sat in meetings where stakeholders asked why, if AI can write code, we need so many developers. I’ve seen roadmaps compressed based on the assumption that AI will make everything faster. I’ve watched budgets get cut because the board read an article about AI replacing programmers.</p><p>Here’s what the actual research shows:</p><p>Bain &amp; Company’s 2025 Technology Report found that while two-thirds of software firms rolled out AI tools, developer adoption remains low and productivity gains average only <strong>10–15%</strong> — far below marketed claims. Worse, “often the time saved isn’t redirected toward higher-value work” and “even those modest gains don’t translate into positive returns.” (<a href="https://www.bain.com/insights/from-pilots-to-payoff-generative-ai-in-software-development-technology-report-2025/">Bain: From Pilots to Payoff — Generative AI in Software Development</a>)</p><p>Google’s DORA Report — the most comprehensive study of software delivery performance, surveying 39,000+ professionals — found that AI adoption actually degrades delivery performance. For every 25% increase in AI usage, organizations see a 1.5% decrease in throughput and a 7.2% decrease in delivery stability. The report explicitly warns that “AI introduces risk because batch size seems to increase when AI is used. And bigger changesets are riskier.” (<a href="https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report">Google Cloud: 2024 DORA Report</a>) (<a href="https://www.infoq.com/news/2024/11/2024-dora-report/">InfoQ Analysis of 2024 DORA Report</a>)</p><p>Harness’s 2025 State of Software Delivery found that 67% of developers spend MORE time debugging AI-generated code and 68% spend more time resolving AI-related security vulnerabilities. For an organization with 250 developers, they estimate $8 million in annual lost productivity from debugging AI-generated code. (<a href="https://devops.com/survey-ai-tools-are-increasing-amount-of-bad-code-needing-to-be-fixed/">DevOps.com: AI Tools Increasing Bad Code</a>)</p><p>This is what your vendor isn’t telling you.</p><h3>The Technical Debt Time Bomb</h3><p>MIT Professor Armando Solar-Lezama said it best: “AI is like a brand new credit card that is going to allow us to accumulate technical debt in ways we were never able to do before.” (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: How AI Generated Code Accelerates Technical Debt</a>)</p><p>I’ve been building software long enough to know what happens when you prioritize speed over sustainability. You ship fast for a while, and then everything slows down. Every new feature takes longer because it has to navigate around the accumulated mess. Bug fixes introduce new bugs. Refactoring becomes so expensive that nobody attempts it. Eventually, you’re spending 80% of your time maintaining code and 20% building new features.</p><p>AI is accelerating this cycle dramatically. Kin Lane, with 35 years in technology, observed: “I don’t think I have ever seen so much technical debt being created in such a short period of time during my career.” (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: How AI Generated Code Accelerates Technical Debt</a>)</p><p>Ox Security’s analysis of 300+ repositories found that 80–90% of AI-generated code demonstrates “avoidance of refactors” and “by-the-book fixation,” while 70–80% shows DRY principle violations. The code looks like it was written by “an army of juniors” — functional but lacking architectural judgment. (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: How AI Generated Code Accelerates Technical Debt</a>)</p><p>And this is exactly what it is. AI generates code like a very talented junior developer who has read a lot of Stack Overflow but has never maintained a system for five years. It solves the immediate problem. It doesn’t think about what happens next.</p><h3>The Trust Gap Is Growing</h3><p>A troubling divergence has emerged: AI coding tool adoption has climbed from 70% (2023) to 84% (2025), while trust has moved in the opposite direction. Stack Overflow’s 2025 survey found <strong>46% of developers actively distrust AI output accuracy</strong>, with only <strong>33% expressing trust</strong> and a mere <strong>3% reporting “high trust.”</strong> (<a href="https://survey.stackoverflow.co/2025/ai">Stack Overflow 2025 Survey — AI Trust Data</a>) (<a href="https://www.computing.co.uk/news/2025/stack-overflow-developer-survey-identifies-ai-trust-gap">Computing UK: Stack Overflow Survey Identifies AI Trust Gap</a>)</p><p>The JetBrains 2024 survey revealed a dangerous contradiction: <strong>76% of developers believe AI produces more secure code than humans</strong>, yet <strong>59% have security concerns</strong> about AI-generated code. This misplaced confidence collides with academic findings that AI-assisted developers write less secure code while feeling more confident about it. (<a href="https://www.prosus.com/our-insights/portfolio-stories/2024/stack-overflow-2024-developer-survey">Prosus: Stack Overflow 2024 Developer Survey Analysis</a>)</p><h3>Where AI Actually Helps</h3><p>I’m not saying AI coding tools are useless. I use them every day. But I use them for specific things:</p><p>Boilerplate generation. When I need a new React component with the standard imports, hooks setup, and TypeScript interfaces, AI saves me five minutes of typing. Unit test scaffolding. AI is genuinely good at generating test cases for straightforward functions. Learning new frameworks. When I’m exploring a library I haven’t used before, AI helps me understand the patterns faster than reading documentation. Documentation. First drafts of JSDoc comments, README files, and API documentation come together quickly with AI assistance.</p><p>These are real benefits. But they’re incremental improvements to specific tasks, not the transformation that’s being sold.</p><p>Where AI consistently fails: complex business logic, security-critical code, performance optimization, architectural decisions, anything requiring understanding of why the code exists rather than what the code does. The METR study found that experienced developers on familiar codebases — the exact situation where deep knowledge matters most — saw the largest slowdowns from AI assistance. (<a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">METR Study</a>)</p><p>A field study of 4,867 developers across enterprise environments found more nuanced results: junior developers saw 21–40% improvements on unfamiliar tasks, while senior and long-tenure developers showed no statistically significant productivity gains. (<a href="https://itrevolution.com/articles/new-research-reveals-ai-coding-assistants-boost-developer-productivity-by-26-what-it-leaders-need-to-know/">IT Revolution: AI Coding Assistants Boost Developer Productivity by 26%</a>)</p><h3>A Message to Clients</h3><p>If you’re reading this as someone who makes decisions about development budgets, timelines, or team sizes, here’s what I need you to understand:</p><p>AI coding assistants are tools, not magic. They help with some tasks and hurt with others. The 55% productivity gains you’ve seen in vendor presentations are based on artificial benchmarks that don’t reflect real-world development. Independent research shows that for experienced developers working on mature codebases, AI can actually slow things down.</p><p>The code coming out of AI tools has measurable quality problems. It churns more, duplicates more, contains more vulnerabilities. These aren’t theoretical concerns — they’re documented across hundreds of millions of lines of production code. The technical debt your teams are accumulating now will slow them down for years.</p><p>When you compress timelines based on AI assumptions, you’re not getting features faster. You’re getting technical debt faster. When you reduce team sizes expecting AI to pick up the slack, you’re not saving money. You’re reducing the experienced judgment that keeps AI-generated code from becoming a liability.</p><p>The sustainable approach is to treat AI as what it actually is: a capable but unreliable assistant, like a talented intern who can knock out grunt work but whose output needs careful review. Measure success by delivery stability and code quality, not by how many lines of AI-generated code you shipped. Maintain realistic expectations. And listen to your developers when they tell you the tools aren’t living up to the hype.</p><p>Carnegie Mellon’s Ipek Ozkaya offers crucial guidance: “If AI-augmented software development workflows are not designed to prevent, recognize, correct, and account for these mistakes, they are likely to become nightmares down the line, amounting to unmanageable technical debt.” (<a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: How AI Generated Code Accelerates Technical Debt</a>)</p><h3>A Message to Developers</h3><p>For my fellow developers: trust your instincts. If AI-generated code feels wrong, it probably is. If you’re spending more time reviewing and fixing AI output than you would have spent writing the code yourself, that’s a real cost — even if it doesn’t feel like one.</p><p>The research shows something interesting: we consistently overestimate how much AI helps us. We predict it will speed us up, and even when it doesn’t, we believe it did. This perception gap is real and documented. Be skeptical of your own assessment. (<a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">METR Study on Perception Gap</a>)</p><p>Use AI where it genuinely helps: boilerplate, tests, documentation, learning. Be cautious where it doesn’t: complex logic, security, architecture. And push back when stakeholders have unrealistic expectations based on marketing materials rather than measured results.</p><p>The tools will get better. But right now, the gap between what’s promised and what’s delivered is significant. Your job is to ship quality software that works, not to validate vendor claims about revolutionary productivity gains.</p><h3>The Bottom Line</h3><p>Don’t you really not want to read a document when you see it was written by AI?</p><p>Now imagine reading thousands of lines of code like that. Code that looks professional but doesn’t understand your architecture. Code that solves immediate problems while creating future ones. Code that passes tests but contains subtle bugs that will surface in production.</p><p>That’s what your codebase is filling up with. And the research shows it clearly: doubled code churn, eight-fold increase in duplication, 40–48% security vulnerability rates, 19% slowdown for experienced developers.</p><p>AI in software development isn’t a silver bullet. It’s not even a regular bullet. It’s a tool with specific use cases, significant limitations, and costs that aren’t showing up in vendor presentations.</p><p>The sooner we stop pretending otherwise, the sooner we can actually use these tools effectively.</p><h3>References Summary</h3><p>For easy access, here are all the key research sources cited in this article:</p><p><strong>Productivity Studies:</strong></p><ul><li><a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">METR 2025 RCT Study (19% Slowdown)</a></li><li><a href="https://arxiv.org/pdf/2302.06590">Original GitHub/Microsoft 55% Study</a></li><li><a href="https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report">2024 DORA Report</a></li><li><a href="https://www.bain.com/insights/from-pilots-to-payoff-generative-ai-in-software-development-technology-report-2025/">Bain &amp; Company 2025 Technology Report</a></li></ul><p><strong>Code Quality Research:</strong></p><ul><li><a href="https://www.gitclear.com/ai_assistant_code_quality_2025_research">GitClear AI Code Quality 2025</a></li><li><a href="https://leaddev.com/software-quality/how-ai-generated-code-accelerates-technical-debt">LeadDev: Technical Debt Analysis</a></li><li><a href="https://linearb.io/blog/is-github-copilot-worth-it">LinearB Copilot ROI Analysis</a></li></ul><p><strong>Security Research:</strong></p><ul><li><a href="https://cset.georgetown.edu/wp-content/uploads/CSET-Cybersecurity-Risks-of-AI-Generated-Code.pdf">Georgetown CSET Security Study</a></li><li><a href="https://www.businesswire.com/news/home/20250730694951/en/AI-Generated-Code-Poses-Major-Security-Risks-in-Nearly-Half-of-All-Development-Tasks-Veracode-Research-Reveals">Veracode 2025 AI Code Security</a></li><li><a href="https://arxiv.org/html/2211.03622v3">Stanford: Do Users Write More Insecure Code with AI?</a></li></ul><p><strong>Developer Surveys:</strong></p><ul><li><a href="https://survey.stackoverflow.co/2025/ai">Stack Overflow 2025 Developer Survey — AI</a></li><li><a href="https://www.qodo.ai/reports/state-of-ai-code-quality/">Qodo State of AI Code Quality</a></li><li><a href="https://zed.dev/blog/ai-70-problem-addy-osmani">Addy Osmani: The 70% Problem</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0377549753a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>