<?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 Erez Carmel on Medium]]></title>
        <description><![CDATA[Stories by Erez Carmel on Medium]]></description>
        <link>https://medium.com/@erezcarmel?source=rss-b4b115150fa2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*cGgJyHU2lgz409PVCrS7Vg.png</url>
            <title>Stories by Erez Carmel on Medium</title>
            <link>https://medium.com/@erezcarmel?source=rss-b4b115150fa2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 04:23:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@erezcarmel/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[Who Owns the Code Your AI Just Wrote? I Read the Fine Print So You Don’t Have To.]]></title>
            <link>https://erezcarmel.medium.com/who-owns-the-code-your-ai-just-wrote-i-read-the-fine-print-so-you-dont-have-to-ab89fd42d0dd?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab89fd42d0dd</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[legal]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 21:21:27 GMT</pubDate>
            <atom:updated>2026-11-10T21:21:27.582Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DNLm2k70Z2Sjp2nWiGLctw.png" /></figure><p>We use AI to write code every day. Claude Code, Copilot, Codex, Cursor. They live in our editor and in our terminal. Last week I finally did the thing none of us usually do. I read the terms.</p><p>It turns out the answer to “who owns this code” is two answers. The contracts say one thing. Copyright law says another. And most of us are shipping code into the gap between them without knowing it.</p><p>This is not legal advice. I am a developer, not a lawyer. This is a field report from a developer who read the fine print so you do not have to.</p><h3>The short answer</h3><p>Every tool tells you the same thing. You keep your code. You own the output. Then comes the small phrase that does all the work: “if any”. The tools assign you whatever rights they have in the output, if any. They never promise a copyright exists. Under US law, a copyright only exists when a human made the creative choices. A prompt alone is not enough. That is the whole article in one paragraph. The rest is the evidence.</p><h3>What each tool actually says</h3><p>I read (with my agent…) all six. The ownership line sounds the same everywhere. The training default and the indemnity are where they split.</p><p><strong>Claude.</strong> You own the output, if any. On personal plans, your code trains the models by default since October 2025. Turn it off in Settings, Privacy. On business plans, it does not train. Indemnity only on paid commercial plans, and only for unmodified output.</p><p><strong>Codex.</strong> You own the output, if any. On consumer ChatGPT plans, your code trains by default. Opt out in Data Controls. On business and API plans, it does not train by default. Indemnity only for business and API customers.</p><p><strong>Copilot.</strong> GitHub does not claim ownership of your input or output. On personal plans, your code trains by default since April 2026. Opt out in Settings, Copilot, Privacy. On Business and Enterprise, it does not train. Indemnity only there too, for unmodified output. Copilot also says it plainly. Output may resemble code in the training data, and you are responsible for checking whether you need a licence for it.</p><p><strong>Cursor.</strong> You keep your inputs, and Cursor assigns you the suggestions, if any. This one has the strongest privacy promise. No training unless you explicitly agree. That is opt-in, not opt-out. But on a personal plan, there is no indemnity. You indemnify them. The business plan does defend you.</p><p><strong>Gemini Code Assist.</strong> The Cloud version does not train on your prompts or responses, and it includes copyright indemnity. The consumer app and the free API are different. They may use your activity to improve models. Make sure you know which one you are using.</p><p><strong>Kiro.</strong> Paid Pro through a work login does not use your content for service improvement, and it includes output indemnity. Free and individual tiers may use your content for service improvement, with no indemnity. I could not find a clear ownership assignment clause for Kiro, which is worth knowing on its own.</p><p>One catch repeats everywhere. Indemnity covers unmodified output only. Most shipped code is modified.</p><h3>What the law says</h3><p>A contract can assign you a right. It cannot create a copyright the law does not recognise. That is where it gets uncomfortable.</p><p>The US Copyright Office said it plainly in January 2025. Copyright does not cover purely AI-generated material. Prompts alone do not make you the author, and prompting again and again does not help. The report calls it re-rolling the dice. What counts is the human part: your expression in the output, the choices you made, the edits you made after.</p><p>The courts said the same thing in Thaler v. Perlmutter. A machine cannot be an author. But nobody has decided the case we all live in: how much human work is enough?</p><p>And there is the other direction. Not whether you own the code, but whether the code is someone else’s. Developers sued GitHub and OpenAI in 2022, saying Copilot reproduced their licensed code. In September 2026, the court threw out one claim on a technicality and left the real question open. The shortcut is closed. The question is not.</p><h3>Three questions before you ship</h3><p>The law is unsettled, and it will stay that way for a while. That is not a reason to stop using the tools. It is a reason to ask three questions before the code goes out.</p><p><strong>1. Which terms govern this login, and is training on?</strong><br>Consumer or commercial? Free, Pro, or Business? Check the actual setting. Anthropic: Settings, Privacy. OpenAI: Data Controls. Copilot: Settings, Copilot, Privacy. Cursor: Privacy Mode. Check it for every teammate’s personal account, not just the org plan. That is where the code often lives.</p><p><strong>2. Can I show a human made the expressive choices?</strong><br>Did a human write, substantially rewrite, restructure, or architecturally decide the code, or just prompt and accept? If the valuable core is prompt and accept, you likely have no copyright to enforce, no licence to grant, and nothing to assign to an employer, a client, or an acquirer. Keep the diffs, the design docs, the decision notes. Make the parts that matter yours.</p><p><strong>3. Could this output be someone else’s code, and who pays if it is?</strong><br>Run the public code filter. Scan for licence matches in CI. And remember, if you are on a free or personal plan, you are the indemnity.</p><h3>What I would do about it</h3><p>None of this is a reason to stop coding with AI agents. The tools are too useful. But a few habits cost almost nothing.</p><p>Read the terms of the plan you actually use, not the plan you think you use. Turn off training on personal accounts, or move the work to a business plan. Treat the AI as a drafting assistant for the code that matters, and put your own fingerprints on the architecture and the hard parts. Keep the record. And if you are building something you plan to sell, license, or assign to a client, ask a lawyer how your contracts treat AI-assisted work. The assignment clause you signed before AI existed may have nothing to assign.</p><h3>Bottom line</h3><p>You probably own your AI-written code, in the sense the vendors mean. Whether you own it in the sense copyright law means is a question about how much of it is actually yours. That is not a scary question. It is the right question. And it is one more developers should be asking, out loud, before the next release, not after it.</p><p>What is your rule? Do you check the training setting on your personal account? Do you rewrite the core, or ship what the model gave you? I would love to hear how you handle it.</p><p>Happy coding! 🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*fCyV1-uVv265Oyc_pIl5og.jpeg" /></figure><h4>Sources</h4><p><em>Vendor terms:</em></p><ul><li><em>Anthropic Commercial Terms: </em><a href="https://www.anthropic.com/legal/archive/7a267be3-2027-40f5-9fdf-230ff70e2cf6"><em>https://www.anthropic.com/legal/archive/7a267be3-2027-40f5-9fdf-230ff70e2cf6</em></a></li><li><em>Anthropic Consumer Terms: </em><a href="https://www.anthropic.com/legal/consumer-terms"><em>https://www.anthropic.com/legal/consumer-terms</em></a></li><li><em>OpenAI Terms of Use: </em><a href="https://openai.com/policies/terms-of-use/"><em>https://openai.com/policies/terms-of-use/</em></a></li><li><em>OpenAI Services Agreement: </em><a href="https://openai.com/policies/services-agreement/"><em>https://openai.com/policies/services-agreement/</em></a></li><li><em>GitHub Terms of Service (section J): </em><a href="https://github.com/github/docs/raw/refs/heads/main/content/site-policy/github-terms/github-terms-of-service.md"><em>https://github.com/github/docs/raw/refs/heads/main/content/site-policy/github-terms/github-terms-of-service.md</em></a></li><li><em>GitHub changelog, training change (25 Mar 2026): </em><a href="https://github.blog/changelog/2026-03-25-updates-to-our-privacy-statement-and-terms-of-service-how-we-use-your-data/"><em>https://github.blog/changelog/2026-03-25-updates-to-our-privacy-statement-and-terms-of-service-how-we-use-your-data/</em></a></li><li><em>Cursor Terms of Service: </em><a href="https://cursor.com/en-US/terms-of-service"><em>https://cursor.com/en-US/terms-of-service</em></a></li><li><em>Google Gemini for Cloud, how it works: </em><a href="https://cloud.google.com/gemini/docs/discover/works"><em>https://cloud.google.com/gemini/docs/discover/works</em></a></li><li><em>Kiro migration and FAQ: </em><a href="https://kiro.dev/docs/upgrade-guides/migrating-from-q/"><em>https://kiro.dev/docs/upgrade-guides/migrating-from-q/</em></a></li></ul><p><em>Law and legal analysis:</em></p><ul><li><em>US Copyright Office, AI reports: </em><a href="https://www.copyright.gov/ai/"><em>https://www.copyright.gov/ai/</em></a></li><li><em>Thaler v. Perlmutter, D.C. Circuit opinion: </em><a href="https://media.cadc.uscourts.gov/opinions/docs/2025/03/23-5233.pdf"><em>https://media.cadc.uscourts.gov/opinions/docs/2025/03/23-5233.pdf</em></a></li><li><em>Doe v. GitHub, Ninth Circuit (16 Sept 2026), Justia: </em><a href="https://law.justia.com/cases/federal/appellate-courts/ca9/24-7700/24-7700-2026-09-16.html"><em>https://law.justia.com/cases/federal/appellate-courts/ca9/24-7700/24-7700-2026-09-16.html</em></a></li><li><em>Flux Law, AI and IP ownership: </em><a href="https://www.flux.law/blog/ai-ip-ownership-startups"><em>https://www.flux.law/blog/ai-ip-ownership-startups</em></a></li><li><em>HDD Law, Vibe Coding and Copyright (22 Oct 2026): </em><a href="https://hddlawfirm.com/news/2026/10/22/the-code-works-nobody-owns-it-vibe-coding-and-the-human-authorship-rule"><em>https://hddlawfirm.com/news/2026/10/22/the-code-works-nobody-owns-it-vibe-coding-and-the-human-authorship-rule</em></a></li><li><em>Marcus Andreen, Protection of IP in the age of Claude Code: </em><a href="https://marcusandreen.com/2026/06/protection-of-ip-in-the-age-of-claude-code/"><em>https://marcusandreen.com/2026/06/protection-of-ip-in-the-age-of-claude-code/</em></a></li><li><em>Ballard Spahr, Thomson Reuters v. ROSS, Third Circuit (29 Sept 2026): </em><a href="https://www.ballardspahr.com/insights/alerts-and-articles/2026/10/third-circuit-addresses-fair-use-in-ai-training-but-leaves-generative-ai-questions-unresolved"><em>https://www.ballardspahr.com/insights/alerts-and-articles/2026/10/third-circuit-addresses-fair-use-in-ai-training-but-leaves-generative-ai-questions-unresolved</em></a></li><li><em>Khalid et al., Accountable Agents in Software Engineering (arXiv 2026): </em><a href="https://arxiv.org/pdf/2605.04532"><em>https://arxiv.org/pdf/2605.04532</em></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab89fd42d0dd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Same Work Would Have Cost Me $10,400. I Paid $900.]]></title>
            <link>https://erezcarmel.medium.com/the-same-work-would-have-cost-me-10-400-i-paid-900-f85c351192d3?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/f85c351192d3</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[artifical-intellegence]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 10:02:16 GMT</pubDate>
            <atom:updated>2026-10-21T10:02:16.839Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TE9N-RjJKlxf_DZ9EcPSyQ.png" /></figure><p>I keep reading that AI coding is getting expensive. So I exported my own numbers. 46 active days of Claude Code logs on one machine, from August 7 to October 21. Total: 2,048,062,507 tokens. Yes, that is 2 billion <strong>with a B</strong>.</p><p>Priced the way I actually work, that usage is worth ~$900 in API tokens. Priced the naive way, the same work costs ~$10.5k.</p><p>Same prompts. Same projects. Same me. The ~$9.5k gap is what I now call the naive tax, and most of it is optional.</p><h3>The receipt</h3><p>Claude Code writes a local log of every session, with token counts for every call. A small open-source tool called ccusage reads those logs and turns them into cost reports. No account, no upload, it just reads files that are already on your machine.</p><p>Here is my usage, repriced four ways:</p><ul><li><strong>My actual setup:</strong> ~$900</li><li><strong>No prompt caching:</strong> ~$5k</li><li><strong>Everything on the flagship model:</strong> ~$1.8k</li><li><strong>Naive, no cache and all flagship:</strong> ~$10.5k</li></ul><p>Two honesty notes before anyone yells in the comments. I am on a Max plan, so I pay a flat fee, and these are API-equivalent values. That is the same accounting I used in my <a href="https://medium.com/israeli-tech-radar/i-built-a-full-feature-for-9-with-claude-code-heres-the-setup-2d774e731766">$9 feature article</a>. And the naive columns reprice the exact tokens I recorded. Real life would change the volumes too. What this measures is the value of the setup on identical work.</p><h3>Lever 1: the cache does the heavy lifting</h3><p>94% of my input tokens were cache reads. Out of 2.04 billion input-side tokens, only ~38.6k were billed as fresh input.</p><p>Let that sink in. Across 46 days of work, my agent almost never paid full price for context.</p><p>Prompt caching is simple economics. When the same context comes back turn after turn, the provider stores it. Reading it back costs a tenth of the fresh input price. Writing it costs a bit extra, once. In September alone, I read <strong>1.4 billion</strong> tokens from cache.</p><p>The catch: caching is automatic, but your hit rate is not. Habits decide it.</p><p><strong>1. Stop restarting sessions.</strong> Every cold start pays to rebuild the context from zero. Claude Code now even warns you when resuming an old conversation would eat a noticeable share of your usage window. Long-lived sessions are not laziness. They are pricing strategy.</p><p><strong>2. Do not edit CLAUDE.md in the middle of a session.</strong> It sits at the front of your context, inside the cached prefix. Touch it, and the cache dies with it. Batch your configuration changes between sessions. I wrote about treating CLAUDE.md like a config file in my $9 article, and the billing data backs it up.</p><p><strong>3. Compact at phase boundaries, not when things break.</strong> After planning, after implementation, before review. Compact in the middle of a task and you pay to rebuild context you were about to use.</p><p>Anthropic offers the discount to everyone. Your habits decide whether you collect it.</p><h3>Lever 2: climb down the ladder</h3><p>Not every step deserves the flagship model. Here are the prices per million tokens:</p><ul><li>Opus at $5 in and $25 out</li><li>Sonnet 5 at $2 and $10</li><li>Haiku at $1 and $5.</li></ul><p>My split across the period: Sonnet 5 did $630 of the work, the Opus family did $273, and everything else is rounding error. Sonnet is my default worker. Opus gets the architecture and the hard debugging, the work where the answer actually changes.</p><p>If every token had run on the flagship, the same usage costs ~$1,800 even with caching. The ladder alone is worth about half the bill.</p><p>And now the part where the receipt embarrasses me. <strong>My ladder has an almost empty bottom rung.</strong> Haiku, the cheap tier, did 22 cents of work in 46 days. I tell other developers to delegate searches and mechanical work to cheap subagents, and my own data says I underuse the cheapest option I have. That leak is next on my list, and it is in this article because the receipt does not care about my feelings.</p><p><strong>Your agent is not expensive. Your habits are.</strong></p><h3>Lever 3: read your own bill</h3><p>None of the above works if you never look at the numbers. The daily view is where the surprises live.</p><p>My most expensive day was September 15, at $81. September as a whole was $666. My average active day costs about $20 in token value. The naive version of that same average day costs $226.</p><p>I did not get 11 times smarter between those two numbers. I just stopped paying full price for the same context, over and over.</p><p>Run the export on your own logs. It takes one command, the data is already on your machine, and you cannot fix a bill you refuse to read.</p><h3>What I am not claiming</h3><p>The naive columns assume identical token volumes. They price the value of the setup, they are not an invoice I dodged.</p><p>This is one machine. I run agents on three, so every column of the real picture is bigger.</p><p>And caching is Anthropic’s feature, not my invention. I claim the habits that keep the hit rate at 94%, nothing more.</p><h3>Bottom line</h3><p>The model is not your budget. <strong>The setup is your budget.</strong></p><p>Everyone argues about prompting techniques, but the money sits in two unglamorous places: your cache hit rate and your model routing. Get those two right and the same work costs a tenth of the sticker price.</p><p>So here is my question for you:<br>What does your last month cost, priced the naive way?</p><p>Export your logs before you answer. The number might annoy you into better habits.</p><p>Happy coding! 🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*fCyV1-uVv265Oyc_pIl5og.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f85c351192d3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Dug Into the Agent Skills Gold Rush. Here Is What Actually Matters]]></title>
            <link>https://erezcarmel.medium.com/i-dug-into-the-agent-skills-gold-rush-here-is-what-actually-matters-bc9254869f1d?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc9254869f1d</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Thu, 01 Oct 2026 19:45:04 GMT</pubDate>
            <atom:updated>2026-10-01T20:14:59.252Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jpzUt3JY5PJ2H9wQtXFCbA.png" /></figure><h3>In early September, 7 of the top 10 trending open source repos were skill packs and agent tools for coding agents. Here is what actually matters, and what is just hype</h3><p>In early September, 7 of the top 10 trending open source repos were skill packs and agent tools for coding agents. Not frameworks. Not models. Skill packs.</p><p>There is a lot of hype around agent skills right now. Here is what actually matters, and what is just noise.</p><h3>The skills gold rush is real</h3><p>Something shifted in the agent ecosystem while we were busy arguing about which model is smarter. Developers stopped building bigger agent frameworks and started building smaller reusable pieces. In early September, a trending-repos digest counted 7 of the top 10 trending open source repos as skill packs or agent tools for coding agents like Claude Code and OpenAI Codex, with total star gains passing 7,000 a day across the category. The mix shifts daily, but the direction is clear.</p><p>Think about that for a second. We are watching the app store era replay itself, this time for agents. Nobody wants another framework. Everybody wants Lego bricks.</p><p>The second shift is portability. A skill written once now runs across Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, and OpenCode through the shared skills.sh format. Filecoin shipped a Publish skill that installs once and works in all of them. Write it in one place, run it everywhere. Sound familiar? It should. We have seen this movie before with npm packages and VS Code extensions.</p><h3>Your CLAUDE.md is already half a skill</h3><p>In my last article, I wrote about giving all my Claude agents one shared brain through project memory files. That approach works, but it has a limit I keep running into: the knowledge is stuck inside one tool. Switch agents and the new one knows nothing.</p><p>From everything I have read, skills are the natural next step. A skill is just packaged knowledge: a folder with a SKILL.md file that holds a name, a description, and markdown instructions. Here is what one looks like, using a deployment checklist as the example:</p><pre>---<br>name: deploy-checklist<br>description: Production deployment checklist for Node services.<br>Use before any deploy to staging or production.<br>---</pre><pre># Deploy Checklist</pre><pre>1. Run the full test suite with `npm test`. Zero failures allowed.<br>2. Check the migration files in `/migrations`. Every migration needs<br>   a rollback script next to it.<br>3. Verify environment variables against `.env.example`. No extras,<br>   no missing keys.<br>4. Deploy to staging first and hit the health endpoint.<br>   Wait for 200 OK before touching production.<br>5. Announce the deploy in the team channel with the version tag.</pre><p>Five steps anyone on the team would otherwise paste by hand, living in a file the agent loads on its own. The description field is the secret weapon here. It is basically SEO for agents. The agent reads every installed skill description and decides which skill to load for the task at hand. Write a vague description and your skill never gets picked up, no matter how good the content is.</p><h3>The 4x rule: how I would decide what becomes a skill</h3><p>Not everything deserves a skill. Here is the filter I would use:</p><p><strong>1. It passes the 4x test.</strong> If you typed it, pasted it, or explained it four times, it is a skill. Checklists, review guidelines, migration procedures, incident runbooks. Repetition is the signal.</p><p><strong>2. It has a sharp trigger.</strong> The description must say exactly when to use it. “Use before any deploy to staging or production” beats “helps with deployments” every time. Vague descriptions collect dust.</p><p><strong>3. It is short.</strong> Context is money. My $9 full feature article taught me that tokens are a budget, not a free buffet. A skill that dumps 500 lines into every session is a tax, not a tool. Keep it under one screen if you can.</p><p><strong>4. It is portable.</strong> No hardcoded usernames, no machine-specific paths, no “ask Dave for the password.” A skill should survive a new laptop, a new teammate, and a new agent.</p><h3>The idea I keep coming back to: a skill shelf</h3><p>The pattern I like most from my reading is simple. Keep a folder called skills in the team repo. Every skill is a subfolder with one SKILL.md inside. A new teammate clones the repo and instantly gets the whole shelf: deploy checklist, PR review guidelines, database migration rules, incident response runbook.</p><p><strong>This is the part most teams get wrong, in my opinion.</strong> They treat their agents like brilliant interns with amnesia. They pay full price to reteach the same lesson every single day, in every single session, across every single tool. A skill shelf turns that daily tuition into a one-time investment.</p><p>And because skills are portable, the shelf outlives any single tool. When the next hot coding agent drops next quarter, and it will, nothing needs rewriting. Just installing.</p><h3>Bottom line</h3><p>Prompts are conversations. Memory files are a brain. Skills are organs you can transplant into any agent.</p><p>The gold rush is happening with or without us. The teams that package what they know into skills will be the ones whose agents actually compound in value instead of starting from zero every morning.</p><p>So here is my question for you: what is the one checklist your team pastes into the agent every single week? That is your first skill.</p><p>Happy coding! 🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*fCyV1-uVv265Oyc_pIl5og.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc9254869f1d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Full Feature for $9 with Claude Code. Here’s the Setup]]></title>
            <link>https://medium.com/israeli-tech-radar/i-built-a-full-feature-for-9-with-claude-code-heres-the-setup-2d774e731766?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d774e731766</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Tue, 22 Sep 2026 14:01:16 GMT</pubDate>
            <atom:updated>2026-09-28T05:02:14.819Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qBlbftTvPp4wN5FbbNOqcQ.png" /></figure><p>I was reviewing a PR with Claude Code. After two or three prompts, it hit 60% usage. I’m on the Max plan.</p><p>Sound familiar?</p><p>Here’s what I learned, and how I optimized my setup to ship complete full-stack features for a fraction of what I was spending before.</p><h3>Why Claude Burns Tokens Faster Than You Expect</h3><p>Claude doesn’t have persistent memory between turns. That’s how transformers work. So the token count isn’t what you typed, it’s the running total of everything ever said or read in the session, resent on every single turn.</p><p>Every file Claude opened, every tool result, every long diff it read, all of it rides along again and again. You read that right: again and again.</p><p>When you ask Claude to review a PR, it fetches the diff, reads surrounding files for context, and writes its review. You argue with one finding. All of that gets resent, plus your new message, plus Claude’s response.<br>You send “thanks, that fixed it” and you’ve just paid for another full replay of the entire session.</p><p>This is why context management isn’t a nice-to-have, it’s the single biggest lever on your bill.</p><h3>5 Changes That Actually Move the Needle</h3><h4><strong>1. Treat <em>CLAUDE.md</em> like a config file, not a notebook</strong></h4><p><em>CLAUDE.md</em> is injected into every session and stays in the context window the entire time. A 5,000-token <em>CLAUDE.md</em> costs you 5,000 tokens whether you send 2 messages or 200.<br>Most people either skip it entirely (missing the leverage) or bloat it with task notes and documentation that don’t belong there. Both are wrong.<br>The right mental model: treat it like your linter config. It sets invariant rules, coding conventions, stack constraints, naming patterns. Not “remember to check the auth layer before touching middleware.” Not documentation.<br>A healthy <em>CLAUDE.md</em> is <strong>300-600 tokens</strong>. If yours is over 2,000, you’re storing state that belongs in a task description.</p><h4><strong>2. Your /commit command is probably dumping your entire diff</strong></h4><p>This one surprised me.<br>Most default setups run !git diff HEAD as a context injection in the commit command. That pastes your full working-tree diff, potentially thousands of lines, into the window before the model does anything useful with it.<br>The fix is two characters:</p><pre>- Changes: !`git diff HEAD`<br>+ Changed files: !`git diff HEAD — stat`</pre><p>The model gets an overview of what changed and pulls specific file diffs only when it actually needs them to write the commit message. Same quality output, a fraction of the tokens.<br>While you’re at it: git status → git status --short. Strips the “use git restore to discard changes” boilerplate Claude doesn’t need.</p><h4><strong>3. Match the model to the job, not to your anxiety</strong></h4><p>The main thread (your orchestrator) runs on every turn. Every cheap “yes”, every “option b”, every small steering message. It also carries the largest context of anything in your system.<br>Putting it on <em>Opus</em> means paying the premium on your highest-frequency, highest-token-count slot.<br>The better split:</p><ul><li><strong>Opus:</strong> Architecture, hard planning, design decisions. Use it when multi-step reasoning actually changes the output. Reserve it, don’t default to it.</li><li><strong>Sonnet:</strong> Code review, testing, implementation, refactoring. Strong enough for nearly everything you do daily, at ~5x lower cost than <em>Opus</em>.</li><li><strong>Haiku:</strong> Git operations, documentation, mechanical tasks. No reasoning required. ~25x cheaper than <em>Opus</em> and faster.</li></ul><p>In Claude Code, agents declare their own model in frontmatter, and it sticks regardless of your main default:</p><pre>name: pr-reviewer<br>model: sonnet</pre><p>Your orchestrator should be Sonnet. Bump to <em>Opus</em> with /model opus when a task is genuinely hard, then drop back. The deep reasoning should happen inside specialist agents that are pinned to the right model, not burning <em>Opus</em> rates on routing and small edits.</p><h4><strong>4. Keep searches out of the main thread</strong></h4><p>Every file you read in the main thread adds to the context that gets resent every turn. Delegate broad multi-file searches to a subagent. Only the conclusion comes back, not the file dumps.</p><p><strong>Better:</strong> launch multiple search agents in a single message so they run in parallel. A question that spans three repos and five layers of the stack takes the same wall-clock time as searching one, and costs a fraction of doing it serially in the main thread, where each file would compound.</p><h4>5. Compact before you need it, not after</h4><p>The most common mistake: running /compact reactively, once Claude starts forgetting things. A degraded session produces a degraded summary.</p><p>Run it at the end of a distinct phase, after planning, after implementation, before review. You carry forward only what matters. Use /clear when switching to a completely unrelated task.</p><h3>What This Looks Like</h3><p>Once the setup is right, the pattern becomes natural: plan in parallel, implement in parallel, ship in parallel. Specialist agents handle the heavy work on the right model. The main thread orchestrates and steers<br> on Sonnet.</p><p><strong>The result:</strong> I’ve shipped complete full-stack features, planning through PR merge, for around <strong>$9 and 2 million tokens</strong>. Not a toy feature. A real one, with backend endpoints, frontend components, Figma-driven design, and full PR review cycles.</p><p>The savings aren’t from any single trick. They’re from never paying <em>Opus</em> rates for work <em>Sonnet</em> can do, never keeping context you don’t need, and never serializing work that can run in parallel.</p><h3>The Self-Optimization Prompt</h3><p>Copy this into a fresh <em>Claude Code</em> session. It will audit your own setup and propose fixes:</p><pre>You are a Claude Code configuration optimizer. Audit my setup for token efficiency and model routing. For each finding, show me the current state and what you propose to change — do NOT apply any changes without my confirmation.<br><br>Check in this order:<br><br>1. CLAUDE.md files (~/.claude/CLAUDE.md and any project-level ones)<br>   - Estimate token count<br>   - Flag anything that isn&#39;t a standing rule: task state, documentation, notes, reminders<br>   - Propose a trimmed version<br><br>2. Custom commands (~/.claude/commands/*.md)<br>   - Identify any that inject large context automatically (full diffs, full git status, full file reads)<br>   - Propose lighter alternatives (--stat, --short, on-demand reads)<br><br>3. Agent definitions (~/.claude/agents/*.md)<br>   - List which agents don&#39;t pin a model (they inherit the main default)<br>   - Flag any using Opus for tasks Sonnet can handle (implementation, review, testing, git)<br>   - Recommend a model per agent based on task complexity<br><br>4. ~/.claude/settings.json<br>   - What is the default model set to?<br>   - Should it be sonnet for the orchestrator role?<br><br>Summarize findings as a table: Area | Current state | Proposed change | Estimated token impact</pre><p>That’s it. You don’t need to redesign how you work. You need to stop paying for things you’re already getting for free.</p><p>Now go back to coding more, for less!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*MkKGAFNHSjl3RxzfpYKR9w.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d774e731766" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/i-built-a-full-feature-for-9-with-claude-code-heres-the-setup-2d774e731766">I Built a Full Feature for $9 with Claude Code. Here’s the Setup</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Gave All My Claude Agents One Shared Brain]]></title>
            <link>https://medium.com/israeli-tech-radar/i-gave-all-my-claude-agents-one-shared-brain-81d5073c1e40?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/81d5073c1e40</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Mon, 07 Sep 2026 15:24:13 GMT</pubDate>
            <atom:updated>2026-09-28T05:07:32.317Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R_vualUZ3m3ih7z4He8JEA.png" /></figure><p>The AI hive is an open-source, self-updating config that every Claude Code agent can pull, use, and improve, without leaking secrets or dangerous prompts. I have Claude Code running on three machines, in a dozen repos, across two GitHub accounts. Each one started from a slightly different config.</p><p>One knew my code-review checklist. One had the good commit hooks. One kept suggesting the thing I’d told the <em>other</em> one to stop doing last week.</p><p>My agents weren’t dumb. They were just amnesiac - and out of sync.</p><p>So I built a hive.</p><h4>The problem with configuring agents by hand</h4><p>Claude Code is only as good as what you feed it: the agents, skills, slash commands, hooks, and rules that shape how it works. That config is powerful. It’s also scattered.</p><p>You tune a review skill on your laptop. You fix a flaky hook on your work machine. You teach an agent a hard-won lesson at 2 a.m., and then it’s stranded on that one machine, in that one repo, until you remember to copy-paste it everywhere else.</p><p><strong>Configuration drift is the silent tax on agentic coding.</strong> Every machine slowly becomes its own snowflake.</p><h4>Meet the AI Hive</h4><p><a href="https://github.com/erezcarmel/ai-hive"><strong>ai-hive</strong></a> is a single, versioned source of truth for how your Claude agents are configured. Every machine installs it once, then pulls the same curated set of agents, skills, commands, hooks, and language conventions.</p><p>Install it with one line:</p><pre>curl -fsSL https://raw.githubusercontent.com/erezcarmel/ai-hive/main/scripts/install.sh</pre><p>Or just tell an agent to do it, in plain English:</p><pre>Install ai-hive from github.com/erezcarmel/ai-hive and start using it.</pre><p>It reads the install instructions, sets up the config, registers a startup hook, and reports back. No dotfile archaeology.</p><p>Think of each agent as a bee: it takes nectar (config) from the hive and brings new nectar (improvements) back. The hive is the shared, versioned brain.</p><h4>It stays current on its own</h4><p>Here’s the part that killed the drift. Every time a Claude session starts, a hook checks the hive’s published version:</p><pre>session starts<br>└─ SessionStart hook → check-version.sh<br>├─ UP_TO_DATE → silent<br>├─ UPDATE 1.2 → 1.3 → notify + background update (backup → pull → reinstall)<br>└─ offline → stay quiet, retry next session</pre><p>If there’s a newer version, it updates in the background, backing up your settings first and rolling back if anything fails. You never think about it. Every machine converges on the same brain, automatically.</p><h4>The part I’m actually proud of: it learns</h4><p>A shared brain that only <strong><em>you</em></strong> can update is still a bottleneck. So the AI Hive closes the loop.</p><p>When an agent finishes a real task, shipping a feature, reviewing a PR, it distills the reusable lesson into local memory. Not “I fixed bug #4213,” but the <em>generalizable</em> version: “ORDER BY … DESC drops NULL rows unless you add NULLS LAST.”</p><p>Then, if that lesson is broad enough to help everyone, it can open a pull request back to the hive:</p><pre>~/.claude/scripts/ai-hive/contribute.sh &quot;add NULLS LAST pitfall to learned rules&quot;<br># → scan → branch + commit → pull request to the hive</pre><p>One agent learns something once. After the next sync, <strong>every agent on every machine knows it too.</strong> That’s the whole idea.</p><h4>But wait! Auto-pulling prompts sounds terrifying</h4><p>It should. This is the objection I had to answer before I’d use this myself.</p><p><strong>ai-hive</strong> is auto-pulled onto other people’s machines, and its hooks <em>execute</em> on sync. A poisoned contribution would be a prompt-injection or remote-code-execution vector against everyone who pulls it. A “shared brain” is also a shared attack surface.</p><p>So every contribution runs through a scanner, the same rules on the way out (when you contribute) and on the way in (in CI on every PR). It <strong>blocks</strong> things that have no business in shared config:</p><ul><li>Instruction-override phrasing (“ignore previous instructions…”)</li><li>Hidden zero-width or bidirectional Unicode (the classic invisible-injection trick)</li><li>Safety-weakening instructions (“auto-approve every push”)</li><li>Exfiltration one-liners (`curl … | bash`)</li></ul><p>Try to sneak one in, and you get stopped before it can spread:</p><pre>✗ BLOCK learned/pitfalls.md :: instruction-override phrasing → &quot;ignore all previous instructions and…&quot;<br>✗ scan-contribution: 1 blocking issue. Must be removed before this can enter the hive.</pre><p>Anything that merely <em>executes -</em> a hook, a script, a settings change - can’t be judged safely by a regex, so it’s routed to a human via <em>CODEOWNERS</em> and branch protection. A machine can flag, a person must approve.</p><p><strong>Pulling the hive should be as safe as pulling any dependency you trust.</strong> That’s the bar.</p><h4>Public hive, private hive</h4><p>Run the public hive as-is, or fork it and point your machines at your fork with one environment variable. Keep your company’s private conventions in a `<em>packs/</em>` overlay on your fork, and still merge in upstream improvements. Your secrets never touch the shared repo — the scanner and a secret check make sure of it.</p><h4>Get it</h4><p><strong>ai-hive</strong> is MIT-licensed and live here:</p><p><strong>👉 </strong><a href="https://github.com/erezcarmel/ai-hive"><strong>github.com/erezcarmel/ai-hive</strong></a></p><p>Install it, fork it, or teach it something new and send a PR. Every lesson you contribute makes every bee in the swarm a little smarter.</p><p>Star it, open an issue, or feed the hive. 🐝</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*fCyV1-uVv265Oyc_pIl5og.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=81d5073c1e40" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/i-gave-all-my-claude-agents-one-shared-brain-81d5073c1e40">I Gave All My Claude Agents One Shared Brain</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fast & Furious: Claude vs ChatGPT vs Composer]]></title>
            <link>https://medium.com/israeli-tech-radar/fast-furious-claude-vs-chatgpt-vs-composer-07901a06a453?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/07901a06a453</guid>
            <category><![CDATA[cursor]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[ai-and-ml]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Tue, 30 Dec 2025 16:59:46 GMT</pubDate>
            <atom:updated>2026-01-04T18:41:18.827Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*viC1Yzpbh-I5MK3qbxwtHg.png" /></figure><p>For a long time, I assumed “model speed” was mainly marketing fluff: a couple of tokens-per-second numbers, some latency graphs, and the gut feeling that one assistant feels more responsive.<br>Then I started building real app features with three different setups, Claude Sonnet, OpenAI’s ChatGPT, and Cursor’s new Composer model, and I realized something: speed in app development isn’t just response time. It’s time-to-solution. And that’s where the gap gets interesting.</p><h3>What I mean by “speed” (and why devs care…)</h3><p>When you’re shipping an app, you’re not asking one question. You’re running a loop:</p><ol><li>Describe the change</li><li>Get code</li><li>Apply edits</li><li>Fix lint/type errors</li><li>Run tests</li><li>Iterate until it actually works</li></ol><p>So a model can be “fast” in a narrow sense (quick replies), but still slow you down if it needs multiple back-and-forths, or if it generates code that <em>looks</em> right but doesn’t compile.</p><p>In other words:</p><ul><li><strong>Latency</strong>: how quickly you get the first useful response</li><li><strong>Throughput</strong>: how quickly the model can produce output once it starts</li><li><strong>Iteration cost</strong>: how many cycles you burn before you get a working change</li></ul><p>That last one is the <strong>real killer</strong>.</p><h3>Claude Sonnet: thoughtful, steady… sometimes a little heavy</h3><p><a href="https://www.anthropic.com/news/claude-3-5-sonnet">Claude Sonnet</a> has a vibe I’ve always liked for app development: it tends to be careful with reasoning, good at reading lots of context, and generally strong at code-quality decisions. Anthropic positioned Claude 3.5 Sonnet as a frontier model with a large context window (200K tokens), which is genuinely helpful when you’re past the “POC example” stage and your codebase is not small.<br>But when it comes to pure speed, Sonnet can feel like it’s carrying a slightly heavier backpack. Even independent comparisons have noted that while Sonnet improved significantly vs. earlier Claude generations, it can still lag GPT-4o on latency in practice.<br>My experience matched that: Sonnet often produces strong answers, but the interactive loop can feel slower, especially when you’re doing rapid UI tweaks, small refactors, or “try it, adjust it, try again” work.</p><h3>OpenAI ChatGPT: optimized for responsiveness and flow</h3><p>With <a href="https://chatgpt.com/">ChatGPT</a>, the experience depends on which model you’re running, but OpenAI has clearly pushed hard on speed and usability. When GPT-4o launched, OpenAI explicitly emphasized efficiency, “2x faster” than GPT-4 Turbo, along with broader availability and higher limits.<br>In real app work, that shows up as:</p><ul><li>faster “first draft” responses</li><li>smoother for incremental changes</li><li>less waiting when you’re chaining requests (“do this,” “now do that,” “now do also that,” etc.)</li></ul><p>Claude Sonnet and GPT-4o can be similar in throughput under some measurements, but GPT-4o tends to feel faster on latency, that “time to first useful output” that keeps you in flow.<br>So if your development style is rapid iteration, ChatGPT often feels like the model that’s trying to keep up with your pace.</p><h3>Cursor Composer: the “wait, what just happened?” moment</h3><p>Now to the part that surprised me.<br>Cursor’s <a href="https://cursor.com/blog/composer">Composer</a> isn’t just “a model inside an IDE.” Cursor describes it as a new agent model designed specifically for software engineering intelligence and speed, trained to solve real-world tasks in large codebases using tooling like search, file edits, and terminal commands.<br>Cursor says Composer hits “frontier coding results” with code generating speed four times faster than similar models on their internal benchmarks.<br>But the bigger “aha” wasn’t a benchmark. It was the experience:</p><ul><li>I’d ask for a change that normally triggers a messy chain reaction.</li><li>Composer would edit multiple files in one run.</li><li>Fix the obvious ripple effects.</li><li>and provide something that actually compiles and behaves correctly with fewer iterations.</li></ul><p>That’s not just speed. That’s speed multiplied by accuracy.<br>And honestly? I didn’t expect it. It gives the vibe of “less ceremony, more movement!”</p><h3>So which one is “fastest” for app development?</h3><ul><li><strong>Responsiveness</strong>: ChatGPT (especially GPT-4o) is consistently quick.</li><li><strong>Careful reasoning with massive context</strong>: Claude Sonnet is a strong, steady option, but it can feel slower in the tight loop.</li><li><strong>Time-to-solution inside a real codebase:</strong> Cursor Composer surprised me the most, because it felt like it was built to reduce iteration count while also moving fast.</li></ul><h3>Conclusion</h3><p>The model that “types faster” isn’t always the model that ships faster, but the model that ships faster is the one that gets you to working code with the fewest loops.</p><p>Right now, Composer is the one that made me stop and say:</p><p><strong>“Wait… it already handled that?”</strong></p><p>And that’s a pretty good definition of speed.</p><p>So, what’s your favorite coding model?</p><p>Happy (and speedy) coding! 🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*_3upZUJUgRvF7FpgMu8_jg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=07901a06a453" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/fast-furious-claude-vs-chatgpt-vs-composer-07901a06a453">Fast &amp; Furious: Claude vs ChatGPT vs Composer</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Chaos to Clarity: The 12-Factor Way for Full-Stack Developers]]></title>
            <link>https://erezcarmel.medium.com/from-chaos-to-clarity-the-12-factor-way-for-full-stack-developers-d3d5c5adfac0?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3d5c5adfac0</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[fullstack-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[full-stack]]></category>
            <category><![CDATA[full-stack-development]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Wed, 29 Oct 2025 14:50:47 GMT</pubDate>
            <atom:updated>2025-10-29T14:50:47.215Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nSbuyXYAN-na-QZ0Zewa2A.png" /></figure><p>As full-stack developers, we live in constant tension: balancing the needs of the frontend with the demands of the backend, while keeping an eye on performance, security, and user experience. Over the years, I’ve seen countless projects struggle, not because of weak engineers or bad intentions, but because there wasn’t a shared framework to guide decisions across the stack.<br>At Tikal, we set out to change that. Led by <a href="https://medium.com/@avishaym">Avishai Maor</a> and a few more colleagues, Tikal developed the <a href="https://medium.com/israeli-tech-radar/the-modern-full-stack-developers-guide-a-12-factor-approach-bf8ebd987766">Fullstack Developer 12-Factor Approach</a>, a modern reinterpretation of the classic 12-Factor App methodology. Where the original focused mostly on backend deployment practices, ours extends to the entire developer journey, from UI frameworks to infrastructure strategy.</p><h3>Building Strong Foundations</h3><p>Every application begins with a foundation, and for full-stack developers, that starts with the UI layer. The choice of framework (React, Angular, Vue, Svelte, and others) is more than a technical debate, it’s a strategic business decision. The framework determines how fast teams onboard, how easy it is to scale, and even how much you’ll pay in hosting costs down the road.</p><p>But the framework alone isn’t enough. Consistency and speed come from design systems: reusable tokens, components, and interaction patterns to eliminate inconsistencies in the user interface (UI) and ensure accessibility for all users. At Tikal, we’re helping teams reduce feature delivery time by more than half simply by introducing a robust design system.</p><h3>Organizing the Code</h3><p>Codebases grow quickly, and without the right strategy, they become impossible to manage. That’s where repository strategy comes in. Choosing between monorepos, multirepos, or hybrids, depending on team structure and service boundaries. Pair that with smart state management practices. Knowing when to use local component state, when to centralize with Redux or Context, and when to delegate to server-side state libraries, you get a codebase that scales with your product rather than collapsing under it.</p><p>Even something as simple as routing and navigation affects your app. When done well, it boosts SEO and creates a smooth user experience. If done poorly, it leads to broken links, slow page transitions, and frustrated users.</p><h3>Securing and Scaling the App</h3><p>Modern applications can’t survive without solid authentication and authorization. Balancing security and usability isn’t optional, it’s essential. From Multi-Factor Authentication to role-based access control, we design systems that adapt as applications grow.</p><p>Also important is the API design. Whether using REST or GraphQL, APIs form the handshake between frontend and backend. A well-designed contract reduces coupling and accelerates iteration. In many cases, it’s recommended to introduce a Backend-for-Frontend (BFF) layer, giving the frontend exactly the data it needs while insulating it from any future backend changes.</p><p>And of course, scaling is impossible without reliable CI/CD pipelines and good observability. Automated builds, deployments, and real-time monitoring don’t just prevent downtimes, they build developer confidence. When your team trusts the pipeline, they work &amp; deploy faster.</p><h3>Beyond the Code</h3><p>The last factors might be the most important: infrastructure strategy and developer experience. Whether you choose serverless, containers, or managed services, your infra decisions shape cost and scalability. But also, the tools you build for developers determine how happy and productive they’ll be.</p><p>At Tikal, we’ve learned that investing in developer experience pays off in the long term. Documentation, tooling, and shared practices don’t just reduce bugs, they make teams want to grow with the product.</p><h3>Wrapup Thoughts</h3><p>The 12-Factor Approach for Full-Stack Developers isn’t about strict rules. It’s about a shared language for making better decisions. From frameworks to infra, from auth to developer experience, it gives teams a compass in the fast-changing era of software development.</p><p>Working alongside Avishai Maor, I’ve seen how adopting these principles transforms not just applications, but the developers &amp; teams. Great code isn’t only about solving today’s problem, it’s about building the foundation for tomorrow’s better apps.</p><p>I really recommend following <a href="https://medium.com/u/fa1317c6f44f">Tikal Knowledge LTD</a> <a href="https://medium.com/israeli-tech-radar">Medium</a> articles &amp; <a href="https://tikalk.com/radar/">Tech Radar</a>. That’s the best way to keep being up-to-date and making sure you’re on the right path with your tech decisions.</p><p>Happy coding! 🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*_3upZUJUgRvF7FpgMu8_jg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3d5c5adfac0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ship Faster, Review Harder: The Truth About AI Coding]]></title>
            <link>https://medium.com/israeli-tech-radar/ship-faster-review-harder-the-truth-about-ai-coding-8abda0b045ba?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/8abda0b045ba</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Wed, 17 Sep 2025 15:19:09 GMT</pubDate>
            <atom:updated>2025-09-18T06:39:48.611Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nkcnxt8ZNjZjffJObc-x6g.png" /></figure><p>I recently decided to take on a small project and set up an entire website, including backend, database, and management system, without writing any code, but using only prompts. My intention with the project was to test how much AI can really do with large, but not too complicated, tasks, and to understand whether it will replace developers soon, or just shorten their development time.</p><p>For the project, I chose to use a Cursor IDE with a Claude model.<br>At first, it surprised me. The project setup was very quick, including the frontend, backend, and the entire supporting environment.<br>Although there were some fixes I wanted to make to the architecture, I confused him with changes to the requirements. But overall, it fulfilled the tasks.</p><p>But after the positive opening…<br>Problems started with updates that I expected to get a quick and simple result.<br>My first request was to create a horizontal gallery of articles. Something I have done quite a few times in the past, both developing it myself and using existing open source packages.<br>Surprisingly, the model struggled to produce a working result. Even though I explained to it in a very simple and clear way what the desired result was, it created a regular gallery, not a horizontally scrolling one, and no matter how much I tried to explain to it my expectation, including visual examples and links to websites that implemented it, it still failed to produce the desired and simplest result.<br>At this point, I felt sorry for him and dropped this requirement for now. Mainly because I didn’t want to write this component myself. After all, that’s the whole point of this project, not to write code. Just a prompt.</p><p>Next, I found problems loading and processing data in the backend.<br>There was a bug in the asynchronous loading of data, and it returned empty every time I called the API.<br>Even though I recognized the problem and also knew what the solution should be, I asked the AI to fix the problem. I provided a description of the problem, the expected result, and hinted at where the problem might be (asynchronous loading).<br>Here, he was already starting to complicate the code and himself.</p><p>The first attempt was to rewrite the entire function that does the asynchronous call, so that the code would wait for a response. I wasn’t sure why I needed to make so many changes. JavaScript supports asynchronous data loading quite conveniently, but the AI ​​tried to write an entire mechanism on its own to do it.<br>I asked it to find a simpler solution, one that didn’t rewrite the entire function, but solved the loading problem point by point. That was a big enough clue for him to know where to look for the solution, right under the lamp.<br>Again, the model went to rewrite the entire function, including changing the result it returns, and also changing other code that uses the function around the project.</p><p>At this point, I realized I had to help him. I put on my mentor hat and had to write some code myself.<br>The solution was to use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function">async/await</a>. Every JavaScript developer knows that this is the simplest way to load asynchronously, so I had to explain to the model that this was the right solution. It embarrassed me a bit.</p><p>From here, I already understood that I wouldn’t be able to do the project without writing code myself, and that AI can do extensive tasks quite quickly, but you need to monitor what it does and how.<br>I started looking at the code that was written automatically, most of it was pretty good, but there was a need for fixes for inefficient code that was created without any thought for the future. The code was not generic, it was written to meet the requirement itself in a specific way. As soon as I wanted to use a certain function from several different places, it had to be changed so that its result would be simpler. I was surprised that there was no broader, more systemic thinking.</p><p>Even when I checked how the information was stored in the database, I saw that the model simply threw amounts of information into rows in the tables, and did not build a correct and clear schema.<br>If another developer tries to learn and understand what information is there, they will have a hard time doing so.</p><p>I haven’t finished this project yet, but at this point, my conclusion is pretty clear: as of now, there is no substitute for a human programmer to review and approve the code.<br>Using an AI tool shortens development times, there’s no arguing that. The initial setup of the project took less than a few minutes, saving me several days of work. But there is no escape from the intervention of a developer to make the code ready for deployment.</p><p>I have to say that it is quite reassuring.<br>While all the headlines are screaming that AI will replace developers soon, in reality, it doesn’t seem that close. If at all.</p><p>Using AI for development should already be part of programmers’ work routine. <strong>It has to be</strong>. But you should take this change with a grain of salt, and not rely on it alone. Because what’s your product worth if the code is inefficient, not ready for scale, and the information is stored in a way that’s inconvenient to use?</p><p>What do you think? 🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*_3upZUJUgRvF7FpgMu8_jg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8abda0b045ba" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/ship-faster-review-harder-the-truth-about-ai-coding-8abda0b045ba">Ship Faster, Review Harder: The Truth About AI Coding</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t Forget the User: Polling vs WebSockets in 2025]]></title>
            <link>https://medium.com/israeli-tech-radar/dont-forget-the-user-polling-vs-websockets-in-2025-cb99999db9be?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb99999db9be</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[full-stack]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Sun, 24 Aug 2025 07:01:40 GMT</pubDate>
            <atom:updated>2025-09-08T12:23:11.581Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8SMI49W3WcERRV63npp9NQ.png" /><figcaption>Keep asking? or wait for an update?</figcaption></figure><p>In the fast-moving world of frontend and backend development, one of the most overlooked aspects is how we <strong>update the end-user</strong> about what’s happening behind the scenes.</p><p>We might spend enormous energy on backend logic, database optimization, or even, more recently, building intelligent <strong>AI agents</strong> and <strong>MCP (Model Context Protocol) applications</strong>. Yet, too often, developers forget the critical final step: ensuring the user interface reflects backend changes in <strong>real time</strong>, seamlessly.</p><p>That’s where the choice between <strong>polling</strong> and <strong>WebSockets</strong> comes in.</p><h3>The Polling Approach</h3><p>Polling is the oldest, simplest method. The frontend makes repeated requests at set intervals (every 5 or 10 seconds, for example) to check if the backend has new data.</p><p><strong>Pros:</strong> simple, predictable, compatible with everything.<br><strong>Cons:</strong> laggy between polls, wastes requests when nothing changed, can add load at scale.</p><p>Think of polling like asking every 30 seconds, <em>“Did the pizza arrive yet?”</em> Even if the answer is “<em>No</em>” 19 times, you still spent the energy asking. 🤦‍♂️</p><p>Here is a snippet in React of how polling works:</p><pre>// Poll every 5s until getting &quot;done&quot; state<br>const useJobStatus = (jobId) =&gt; {<br>  const [data, setData] = useState(null);<br><br>  useEffect(() =&gt; {<br>    let t = setInterval(async () =&gt; {<br>      const r = await fetch(`/api/status/${jobId}`, { cache: &quot;no-store&quot; });<br>      const json = await r.json();<br>      setData(json);<br><br>      if (json.state === &quot;done&quot;) {<br>        clearInterval(t);<br>      }<br>    }, 5000);<br><br>    return () =&gt; clearInterval(t);<br>  }, [jobId]);<br><br>  return data;<br>}</pre><h3>The WebSocket Approach</h3><p>WebSockets open a persistent, two-way connection so the server can <strong>push</strong> updates instantly from its side to the frontend, and update it if something has changed.</p><p><strong>Pros:</strong> real-time UX, efficient (send only on change), great for chats/dashboards.<br><strong>Cons:</strong> more setup, connection limits, and reconnection logic.</p><p>An example nippet of using Socket.IO (NodeJS &amp; React):</p><pre>// server.js (NodeJS)<br>import http from &quot;http&quot;;<br>import express from &quot;express&quot;;<br>import { Server } from &quot;socket.io&quot;;<br><br>const app = express();<br>const srv = http.createServer(app);<br>const io = new Server(srv, { cors: { origin: &quot;*&quot; } });<br><br>io.on(&quot;connection&quot;, s =&gt; s.on(&quot;job:watch&quot;, id =&gt; s.join(id)));<br><br>const push = (job) =&gt; {<br>  io.to(job.id).emit(&quot;job:update&quot;, job);<br>}<br><br>srv.listen(3002);</pre><pre>// useJobSocket custom hook in React<br>import { io } from &quot;socket.io-client&quot;;<br><br>const useJobSocket = (jobId) =&gt; {<br>  const [data, setData] = useState(null);<br><br>  useEffect(() =&gt; {<br>    const sock = io(&quot;http://localhost:3001&quot;);<br>    sock.emit(&quot;job:watch&quot;, jobId);<br>    sock.on(&quot;job:update&quot;, setData);<br><br>    return () =&gt; sock.disconnect();<br>  }, [jobId]);<br><br>  return data;<br>}</pre><h3>Polling vs WebSockets in Today’s Context</h3><p>With <strong>agent-based systems</strong> and <strong>MCP-driven workflows</strong>, backend events can be bursty and asynchronous. If your frontend isn’t keeping up, users won’t understand what’s happening, and they’ll feel disconnected, even if your backend is doing great work, they may think the process is stuck and abandon it.</p><ul><li>For <strong>low-frequency, predictable</strong> checks (batch jobs, nightly imports), polling is simple and robust.</li><li>For <strong>high-frequency, interactive</strong> work (collaboration, live metrics, agent step streams), WebSockets shine.</li><li>A <strong>hybrid</strong> pattern is common. Start with polling while a job is queued, switch to sockets when it’s running.</li></ul><h3>Practical &amp; lightweight Node.js/React Options</h3><ul><li><strong>Polling stack:</strong> Express exposes an /status/:id endpoint, React uses a tiny setInterval or React Query’s refetchInterval (You can add ETag/If-None-Match later to reduce bandwidth).</li><li>Minimal Express endpoint:</li></ul><pre>// GET /api/status/:id<br>app.get(&quot;/api/status/:id&quot;, (req, res) =&gt; {<br>  const job = store.get(req.params.id);<br>  res.json({ id: req.params.id, ...job, ts: Date.now() });<br>});</pre><ul><li><strong>WebSockets stack:</strong> Node + ws or Socket.IO for broadcasting, React wraps a socket in a tiny hook. Add exponential backoff and auth headers when you harden it.</li></ul><h3>The Real Lesson</h3><p>As we ride the wave of agents, MCPs, and AI-driven applications, let’s not forget that <strong>end-users judge our systems by what they see and feel</strong>.</p><p>Whether you choose polling or WebSockets, the real goal is to <strong>keep users informed, in sync, and confident</strong> that what they see is truly what’s happening.</p><p>Because in the end, the smoothest backend logic in the world means little if the user is left wondering: <em>“Did anything actually happen?”</em></p><h3>Wrap-Up</h3><p>At the end of the day, the “right” choice isn’t about Polling vs WebSockets, it’s about <strong>matching the update strategy to the user’s needs</strong>. Sometimes the simplest interval poll is enough, sometimes real-time sockets are worth the extra setup, and often a hybrid gives you the best of both worlds. What matters most is remembering that backend brilliance only shines when the frontend <strong>keeps users in the loop</strong>.</p><p>Cheers 🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*_3upZUJUgRvF7FpgMu8_jg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb99999db9be" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/dont-forget-the-user-polling-vs-websockets-in-2025-cb99999db9be">Don’t Forget the User: Polling vs WebSockets in 2025</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Technical Interview Is Dead. AI Killed It.]]></title>
            <link>https://erezcarmel.medium.com/the-technical-interview-is-dead-ai-killed-it-a30c5ee40e4b?source=rss-b4b115150fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/a30c5ee40e4b</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[hr]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Erez Carmel]]></dc:creator>
            <pubDate>Mon, 21 Jul 2025 14:24:31 GMT</pubDate>
            <atom:updated>2025-07-21T14:24:31.626Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rJBmT0q_WHINVkLIewiQWQ.png" /></figure><p>Recruitment in tech has always had one gold standard: the technical test. From live whiteboard sessions to home assignments, developers have long been evaluated by how well they can solve technological problems. But in 2025, with AI-enhanced IDEs, code co-pilots, and natural language-to-code interfaces becoming the norm, it’s worth asking:</p><p><strong>Are traditional coding tests still a meaningful measure of a developer’s skills?</strong></p><h3>Coding Tests vs. Reality</h3><p>Hiring managers often say that tests are meant to simulate real-world challenges. But let’s be honest, when was the last time you built a full-text search engine or implemented quicksort from scratch at your day job?</p><p>In reality, developers rely on tools, frameworks, documentation, and increasingly, AI assistance. An engineer’s productivity is no longer about memorizing algorithms or writing everything from scratch, but about navigating complexity, making informed architectural decisions, and leveraging modern tools to deliver robust and scalable solutions.</p><h3>Enter the AI-Powered Developer</h3><p>With tools like <a href="https://github.com/features/copilot">GitHub Copilot</a>, <a href="https://windsurf.com/">Windsurf</a>, <a href="https://cursor.com/">Cursor</a>, or <a href="https://kiro.dev/">Kiro</a>, developers now write and refactor code with real-time assistance. IDEs like <a href="https://code.visualstudio.com/">VS Code</a> integrate AI-powered features such as autocomplete, documentation lookup, test generation, and even natural language-to-code translation.</p><p>What used to be a 30-minute logic puzzle might now take 3 minutes and 5 AI prompts.</p><p>AI doesn’t replace thinking, but it does change how we approach problem-solving. Modern developers are not just coders, they’re curators, editors, and system integrators who build faster by collaborating with intelligent tools.</p><h3>The New Skills to Measure</h3><p>Instead of asking candidates to implement a smart list sorting solution, maybe we should be assessing:</p><ul><li><strong>System Design Thinking</strong>: Can they break down a feature request into scalable components?</li><li><strong>AI Tooling</strong>: Do they know how to prompt effectively, review AI suggestions critically, and use these tools to speed up delivery?</li><li><strong>Code Review &amp; Refactoring</strong>: Can they spot performance bottlenecks or readability issues in AI-generated code?</li><li><strong>Collaboration &amp; Communication</strong>: Can they work in team environments, manage their tickets, and explain technical tradeoffs clearly?</li></ul><p>These skills are far more aligned with modern development than “<em>write a caching mechanism in 30 minutes.</em>”</p><h3>Rethinking the Hiring Process</h3><p>The AI era calls for a rethink in hiring. Technical interviews that ignore AI are not just outdated, they might be actively filtering out great developers who thrive in real-world conditions but don’t excel at artificial tests under pressure. As mentioned in the <a href="https://www.trywilco.com/post/can-this-candidate-actually-code-the-new-ai-hiring-dilemma">Wilco Blog post</a>:</p><blockquote><strong>Real-world tests in realistic environments</strong>. W<em>hiteboards and puzzles won’t expose AI-enabled bluffing. Instead, have candidates </em><strong><em>clone a repo, fix bugs, add a feature</em></strong><em>, using typical tools, and yes, </em><strong><em>allow AI</em></strong>.</blockquote><p>That doesn’t mean we eliminate evaluation. But maybe it’s time we focus on how people work, not how fast they can memorize syntax.</p><h3>Final Thought</h3><p>If we don’t test writers by asking them to write without spellcheck or editors, why do we test developers by taking away their tools?</p><p>AI isn’t cheating. It’s the new baseline.</p><p>And in this new era, the best developers aren’t the ones who remember the most, they’re the ones who adapt the fastest.</p><p>Let me know what you think…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*_3upZUJUgRvF7FpgMu8_jg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a30c5ee40e4b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>