<?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 Netanel baba on Medium]]></title>
        <description><![CDATA[Stories by Netanel baba on Medium]]></description>
        <link>https://medium.com/@ntnel_baba?source=rss-115e42afa6d4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*5__VNlfTbClK0x9NyVp7zA@2x.jpeg</url>
            <title>Stories by Netanel baba on Medium</title>
            <link>https://medium.com/@ntnel_baba?source=rss-115e42afa6d4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 07:38:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ntnel_baba/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[Training a Master Skill: From Process to Result]]></title>
            <link>https://medium.com/elementor-engineers/training-a-master-skill-from-process-to-result-4a41f81bda31?source=rss-115e42afa6d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a41f81bda31</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Netanel baba]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 06:53:17 GMT</pubDate>
            <atom:updated>2026-06-22T06:53:17.938Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine a skill that generates a <strong>personalized architecture decision record (ADR)</strong> for a developer. It:</p><ul><li>Reads 20 relevant internal docs and past decisions</li><li>Reads the system design document for the current feature</li><li>Reads the developer’s own past ADRs to understand their style and reasoning patterns</li><li>Reads their stated technical preferences and constraints</li></ul><p>And from all of that, it produces a draft ADR that sounds like <em>them</em> — structured around how they think, referencing the sources they’d actually cite, in the format they prefer.</p><p>That’s the kind of output that can’t be faked with a simple prompt. It requires a proper skill.</p><p>The research loop was hard, but we managed to do it. Here is what we learned during the process. I will explain the structure of the skill and what the research flow was (automated as much as possible, for sure)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/704/1*4iStlpcWOXozJ1JHirV1Xw@2x.jpeg" /></figure><h3>Steps For Building a Complex Skill</h3><p>These steps apply to any workflow skill — one that requires multi-step orchestration at runtime. Skip to <strong>the Training</strong> section if you’re already past the design phase.</p><h4>Step 0: Understand the Source Material</h4><p>Because the output is personalized, you first need to understand what makes it unique. That means reading the source material, mapping what inputs drive what outputs, and planning the internal flow before writing a single line of the skill.</p><h4>Step 1: Define the Flow</h4><p>A skill is a workflow — a structured sequence of steps that takes the LLM from input to output without letting it “figure it out” on its own.</p><p>Unlike a bare tool call, a skill gives the model clear stages: gather, plan, collect, and generate. Each stage has a clear input and a clear output that feeds the next stage. This is what separates a reliable skill from an unpredictable prompt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/704/1*Ci7CsWkEsjW0dzCTOKv5eA@2x.jpeg" /></figure><h4>Step 2: Declare Required Inputs Upfront</h4><p>State at the top of the skill exactly what information is needed to run it. If certain inputs are only needed on a conditional path, only request them when that path is triggered.</p><p>For the ADR skill, we declared the feature doc, the target system, and a pointer to the developer’s past ADRs as required inputs.</p><h4>Step 3: Generate a Brief First</h4><p>Before generating the final output, instruct the model to produce a brief — a short internal plan of what it’s going to do and why.</p><p>This serves two purposes: it forces the model to think deliberately before acting, and it creates a reference point that anchors the rest of the workflow. Without it, long-running skills tend to drift from the original intent by the time they reach the output stage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*jrOtFoVlPu9Nyg11TFNpeQ@2x.jpeg" /></figure><h4>Step 4: Second-Phase Resource Collection</h4><p>Now that the brief exists, use it to drive the rest of the work. The first phase gathered what was needed to <em>plan</em>. This second phase gathers what’s needed to <em>execute</em> that plan.</p><p>This distinction matters. Trying to collect everything upfront — before you know what the brief will say — leads to bloated context and irrelevant information. Let the brief tell you what to fetch.</p><h4>Step 5: Generate the Output</h4><p>With a solid brief and the right resources in context, the actual generation step is usually the simplest. The hard work was everything before it.</p><h3>Skill Structure Tips</h3><p>For a highly complex skill, don’t limit yourself to a single SKILL.md file. Use the main file as the workflow entry point, and add supporting files for additional context — examples, reference formats, design notes, edge case handling.</p><h3>The Training</h3><h4>Initialization</h4><p>You can write the initial skill from scratch, but a faster approach is to initialize it with a thinking model and give it everything it needs upfront:</p><pre>/create-skill for a personalized ADR generator.<br>Read this repo, the design docs in Notion, and past ADRs from Confluence.<br>Build the initial skill structure based on what you find.<br>Split into multiple files where it makes sense, and reference them from the main SKILL.md.</pre><p>Adjust the prompt to your own context. The output won’t be final — it’s a starting point.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/704/1*HtlOwN6nAlrBiO2wbnvuoQ@2x.jpeg" /></figure><h4>The Improvement Cycle</h4><p>Once you have a working structure, prepare a set of example prompts paired with expected outputs. These can be real examples or written descriptions of what a good result looks like.</p><p>Then run this loop:</p><ol><li>Run the skill with a prompt in a fresh session</li><li>Pass the output to a separate model acting as <strong>judge</strong> (LLM-as-a-judge)</li><li>Ask the judge: <em>“What changes to the skill would make this output pass?”</em></li><li>Apply those changes, rerun, repeat</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/588/1*dEQmCxqkNShguib3gMFPrw@2x.jpeg" /></figure><p>Set a cap on how many cycles you’ll accept per prompt. Without a cap, you’ll iterate forever.</p><p><strong>The most important part:</strong> your validation criteria. If the judge doesn’t know what “good” looks like, the feedback loop produces noise. Define what a passing output looks like <em>before</em> you start training — be specific enough that the judge can make a binary call.</p><p>For example, we can use an existing result that looks very good to us, ask the model to analyze this result, and convert it to a benchmark (can be multiple results as well). This process can lead to a better understanding and provide a good reference.</p><h4>The Final Test</h4><p>When you think the skill is ready, run it with prompts it has never seen — ideally from a colleague who wasn’t involved in building it. Use a fast model for this pass. Evaluate the results against your criteria. If it passes consistently, you’re done. If not, back to the cycle.<br>Cycles are not known by advanced, just make sure to run it enough times, the more, the better (or worse) the results. Always keep tracking changes.</p><h3>Final Thought</h3><p>The training loop is where most of the real work happens — and it’s also where most teams give up too early. The skill structure gets you most of the way there; the training gets you the rest.</p><p>If your validation criteria are weak, fix them before anything else. Everything downstream depends on them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/625/1*uMoBAH-kIkcB12S77vFkpA@2x.jpeg" /></figure><p><em>Hope this helped at least one person — if it did, like and share. It might help someone else, too.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a41f81bda31" width="1" height="1" alt=""><hr><p><a href="https://medium.com/elementor-engineers/training-a-master-skill-from-process-to-result-4a41f81bda31">Training a Master Skill: From Process to Result</a> was originally published in <a href="https://medium.com/elementor-engineers">Elementor Engineers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Changing Ticket Writing Perspective]]></title>
            <link>https://medium.com/elementor-engineers/changing-ticket-writing-perspective-753dd6023cd2?source=rss-115e42afa6d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/753dd6023cd2</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Netanel baba]]></dc:creator>
            <pubDate>Wed, 13 May 2026 06:27:48 GMT</pubDate>
            <atom:updated>2026-06-08T18:05:20.490Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Why most AI-generated tickets are stuck — and the simple structure that fixes them.</strong></p><p>A Product Manager writes a ticket. An engineer opens it the next morning and has no idea what to build. The acceptance criteria are missing, the example is abstract, and the “why” is buried in paragraph three. With AI in the mix, this often gets worse, not better — it is easy to generate a 50-page ticket, but much harder to generate a useful one.</p><p>This article is about a small framework that fixes that: Persona-Goal-Benefit, and a simple agent that enforces it.</p><h3><strong>Who this is for</strong></h3><p>Product Managers and Designers, primarily. Engineers and AI agents will get value too — a clear ticket is the foundation of the SDLC, no matter who picks it up.</p><h3><strong>The problem with AI-generated tickets</strong></h3><p>AI generates a lot of words. Words are not context. When a ticket is long but unstructured, both humans and agents lose the thread — what is the user trying to do, why does it matter, and what does “done” actually look like?</p><p>The fix is not more text. It is the right text, in the right structure.</p><figure><img alt="Focus on the Persona-concept image" src="https://cdn-images-1.medium.com/max/1024/1*hrtzDuLfdKkxOW27KaSDow.png" /></figure><h3><strong>The Persona-Goal-Benefit structure</strong></h3><p><strong>Every ticket should answer three questions in one line:</strong></p><ul><li><strong>As a [persona] — </strong>WHO benefits from this feature</li><li><strong>I want [goal] — </strong>WHAT they want to do</li><li><strong>So that [benefit] — </strong>WHY it matters</li></ul><p><strong>That is it. </strong>A new engineer (or an agent) should be able to read those three lines and understand the ticket. If they need to ask a clarifying question, the ticket failed.</p><h4><strong>Before and after</strong></h4><p><strong>Before:</strong></p><blockquote><strong>Add a button to the editor to change shortcuts. Should be flexible. See Figma.</strong></blockquote><p><strong>After:</strong></p><blockquote><strong>As a power user of the Elementor Editor, I want to set custom keyboard shortcuts to speed up my workflow and match my muscle memory from other tools.</strong></blockquote><blockquote>Example:<strong> </strong>A user opens Settings → Keyboard, sees the current shortcut for “Duplicate” (Ctrl+D), clicks it, presses Ctrl+Shift+D, and saves. Next time they use Ctrl+Shift+D, the selected widget is duplicated.</blockquote><p>The first version is faster to write. The second one is faster to build.</p><h3><strong>What every ticket needs</strong></h3><p><strong>Essential:</strong></p><ul><li>Persona-Goal-Benefit</li><li>A concrete example (input → expected output)</li><li>Figma or design link</li><li>Acceptance criteria</li></ul><p><strong>Helpful:</strong></p><ul><li>Tech area or domain</li><li>In/Out of scope notes</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SaqXs7UwzxX_kD4owqZYKA.png" /></figure><h3><strong>The Ticket Writer Agent</strong></h3><p>Once the structure exists, you can enforce it. The Ticket Writer Agent is a quality gate — it sits between “ticket written” and “engineering starts”.</p><p>It checks three things:</p><ol><li><strong>Clarity of purpose</strong>. Does the ticket follow Persona-Goal-Benefit? Is the why clear?</li><li><strong>Actionable example</strong>. Is there a step-by-step example with a clear before and after? Abstract examples fail.</li><li><strong>Implementation data</strong>. Is the Figma link there? Are scope notes present?</li></ol><p>If all three pass, the ticket is ready. If any fail, the agent says exactly what is missing.</p><h4><strong>Example: validating a ticket</strong></h4><p>The Ticket Writer Agent runs as a Cursor command (.cursor/commands/writer_agent.mdc).</p><p>It reads the ticket content and outputs either RESULT: PASS or RESULT: FAIL with specific feedback.</p><pre># TICKET WRITER AGENT SYSTEM PROMPT<br># CURSOR COMMAND: validate-ticket<br># Description: Act as a Quality Gate for a user-provided ticket.<br>### Content options<br>Ticket content - work on it directly<br>Ticket ID - see what available tickets manager system MCP you have and fetch it from there (e.g Jira, Asana, Monday or etc.)<br>### Instructions:<br>Read the ticket content provided by the user.<br>Evaluate the three criteria below.<br>If all criteria are met, output: `RESULT: PASS`.<br>If any criterion fails, output: `RESULT: FAIL` and provide a detailed explanation on how to fix the *Failing Criteria*.<br><br>## Criteria Check:<br>- **Clarity of Purpose (Persona-Goal-Benefit):** Verify the ticket explicitly follows the &quot;As a [persona], I want [goal], so that [benefit]&quot; structure. (FAIL if any part is missing or unclear).<br>- **Actionable Examples:** Check if a concrete, step-by-step example is provided that illustrates the problem or solution. (FAIL if the example is too abstract or missing).<br>- **Implementation Data:** Check for the presence of a Figma/Design link or explicit `Out/In scope` notes. (FAIL if these essential data points are missing).</pre><p><strong>Usage: /validate-ticket validate ticket ID ED-12345</strong></p><h4><strong>Example: creating a new ticket</strong></h4><p>A second command (new-ticket) creates a well-formed ticket from a one-line prompt. It walks you through Persona, Goal, Benefit, and Example, then formats the output ready to paste into Jira or GitHub.</p><pre># CURSOR COMMAND: new-ticket<br># Description: Generates a ticket in Persona-Goal-Benefit format.<br><br>PERSONA=$(prompt &quot;Enter the target user Persona (e.g., Power User, Editor):&quot;)<br>GOAL=$(prompt &quot;Enter the desired Goal (I want…):&quot;)<br>BENEFIT=$(prompt &quot;Enter the Benefit (So that…):&quot;)<br>EXAMPLE=$(prompt &quot;Enter a clear, actionable example/use case:&quot;)<br><br>echo &quot;**Ticket Title:**<br>**Persona-Goal-Benefit:**<br>- As a [$PERSONA]<br>- I want [$GOAL]<br>- So that [$BENEFIT]<br>**Example/Context:**<br>$EXAMPLE<br>&quot;<br># The output must be ready to be copied to Jira/GitHub.</pre><p><strong>Tip: </strong>have the new-ticket command call validate-ticket at the end. Agents do not always follow instructions perfectly — making them re-check their own output catches the drift.</p><h3><strong>What you need to run this</strong></h3><ul><li>A ticket management connector (Jira, Asana, Monday — anything with an MCP or known API)</li><li>A code repo connector (GitHub)</li><li>A reasoning-capable model (so the agent actually follows the rules)</li></ul><p>You can wrap both commands inside a single dedicated agent that owns ticket creation and validation. That is the cleanest setup.</p><h3><strong>The bottom line</strong></h3><p><strong>A well-structured ticket means developers and agents start with everything they need — and stop coming back with questions. The Persona-Goal-Benefit format takes thirty seconds to write and saves hours downstream.</strong></p><p><em>Write the ticket once. Write it well.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=753dd6023cd2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/elementor-engineers/changing-ticket-writing-perspective-753dd6023cd2">Changing Ticket Writing Perspective</a> was originally published in <a href="https://medium.com/elementor-engineers">Elementor Engineers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do We Still Need DDD? The “Quick Feature” That Turned Into a Weekend Nightmare]]></title>
            <link>https://medium.com/elementor-engineers/do-we-still-need-ddd-the-quick-feature-that-turned-into-a-weekend-nightmare-e3037f9ad1b8?source=rss-115e42afa6d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/e3037f9ad1b8</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <dc:creator><![CDATA[Netanel baba]]></dc:creator>
            <pubDate>Sun, 01 Feb 2026 18:07:39 GMT</pubDate>
            <atom:updated>2026-02-02T07:39:41.866Z</atom:updated>
            <content:encoded><![CDATA[<p>In the world of React, component libraries, and Nx/Turborepo, Domain-Driven Design (DDD) often feels like overkill. We tell ourselves, “I have Redux/Zustand for state, and I have React Query for data. I don’t need ‘Entities’. I just need to render this JSON.”</p><p>And for the first three months of a standalone React app, you are right.</p><p>But the question isn’t whether you need DDD to <strong>render a UI;</strong> the question is whether you need DDD to <strong>scale across applications</strong>.</p><h3><strong>What is DDD, really?</strong></h3><p>For those who associate the acronym with heavy Java enterprise books: breathe. At its core, Domain-Driven Design is simply the practice of prioritizing the business problem over the technology stack. It means your code structures -Entities, Value Objects, Aggregates- should mirror the real-world language and rules of the business (the Domain), rather than the shape of your database tables or your React component tree.</p><p>For a mid-to-senior developer, DDD is the discipline of strictly isolating “What the app does” (Business Rules) from “How the app shows it” (UI) or “Where the app stores it” (Infrastructure).</p><p>Let me tell you a story about a “minor” UI feature that turned a simple monorepo addition into a nightmare, simply because we thought business logic belonged in useEffect.</p><h3>Do I need to use all the DDD concepts?</h3><p>Well, no.</p><p>You will see in my example (and in any DDD article) that this is not a framework. You can leverage any part as needed.</p><p>In this article, I choose to take several concepts from that and leverage them to solve this use case.</p><p>As every Architect will say, “it depends.” Same here: it depends on what you are trying to achieve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zvAYBJH0V6wUD_bUN_jfhw.jpeg" /><figcaption>DDD can make life easier (Sometimes)</figcaption></figure><h3>The “Simple” Feature: The Cart Banner</h3><p>Imagine you are working in a monorepo for a fashion brand. You have one main application: apps/web-store (Next.js).</p><p>The Product Manager (PM) comes in with a request:</p><blockquote><em>“In the Cart Sidebar, if the user has a ‘Gold’ membership and their cart total is over $100, show a green banner that says </em><strong><em>‘You qualify for VIP delivery!’</em></strong><em>”</em></blockquote><p>Easy. You open your CartSidebar.tsx component. You grab your data from your query hook, and you write this:</p><p>TypeScript</p><pre>// apps/web-store/src/components/CartSidebar.tsx<br>export const CartSidebar = () =&gt; {<br>  const { user } = useUser();<br>  const { cart } = useCart();<br>  // ❌ The Logic Trap: Embedded in the View<br>  const isVipEligible = useMemo(() =&gt; {<br>    if (!user || !cart) return false;<br>    <br>    const isGoldMember = user.tier === &#39;gold&#39;;<br>    const hasHighValue = cart.items.reduce((acc, item) =&gt; acc + item.price, 0) &gt; 100;<br>    return isGoldMember &amp;&amp; hasHighValue;<br>  }, [user, cart]);<br>  return (<br>    &lt;div&gt;<br>      {/* ... cart items ... */}<br>      {isVipEligible &amp;&amp; &lt;SuccessBanner&gt;You qualify for VIP delivery!&lt;/SuccessBanner&gt;}<br>    &lt;/div&gt;<br>  );<br>};</pre><p>This code works. It uses standard React hooks. It’s performant. It ships.</p><h3>The Twist: “Just use it in the new app.”</h3><p>Six months pass. The company is growing. The CTO decides it’s time for a mobile app. You spin up apps/mobile (React Native/Expo) in your monorepo.</p><p>The PM returns:</p><blockquote><em>“We need that ‘VIP Delivery’ check on the checkout screen in the mobile app. Also, the marketing team wants a landing page in </em><em>apps/marketing that checks a user&#39;s status and tells them if they are eligible.&quot;</em></blockquote><p>You smile. “I’m using a monorepo. Sharing code is what we do.”</p><p><strong>But then you hit a wall.</strong></p><p>You can’t import CartSidebar into React Native (it uses &lt;div&gt; and DOM elements). You can&#39;t easily extract the useMemo logic because it relies on the specific useUser and useCart hooks, which are tied to the web-store&#39;s context providers and API clients.</p><h3>The Result: The “Copy-Paste” or The “Frankenstein Hook”</h3><p>You now have two bad choices:</p><ul><li><strong>Copy-Paste:</strong> You copy the reduce and if logic into the React Native app.<br><strong><em>The Risk:</em></strong> Next month, the “Gold” tier is renamed to “Platinum.” You update the Web Store but forget the Mobile App. Mobile users are told they are ineligible when they actually are. Support tickets flood in.</li><li><strong>The Frankenstein Hook:</strong> You try to abstract a useVipCheck hook in a shared library. But this hook forces you to pass in <em>raw</em> data structures, and now your components are cluttered with data-mapping just to satisfy the hook&#39;s requirements.</li></ul><p>The logic is trapped in the “React Layer.”</p><h3>The DDD Solution: Logic Belongs in a Shared Domain Package</h3><p>If we had applied basic DDD, we would have separated <strong>Behavior</strong> from <strong>Rendering</strong>. We would treat the React Components merely as a “View” for our Domain Model.</p><p>In a monorepo, this usually looks like a packages/domain or packages/core library that <strong>has no dependency on React</strong>.</p><p>TypeScript</p><pre>// packages/domain/src/cart/Cart.ts<br>import { User } from &#39;../user/User&#39;;<br>export class Cart {<br>  constructor(private items: CartItem[]) {}<br>  public get total(): number {<br>    return this.items.reduce((acc, item) =&gt; acc + item.price, 0);<br>  }<br>  // The Logic lives HERE. Pure TypeScript. Framework Agnostic.<br>  public isEligibleForVipDelivery(user: User): boolean {<br>    return user.isGoldTier() &amp;&amp; this.total &gt; 100;<br>  }<br>}</pre><p>Now, look at how this simplifies our monorepo consumers:</p><p><strong>1. The Next.js Web Store:</strong></p><p>TypeScript</p><pre>// apps/web-store/src/components/CartSidebar.tsx<br>export const CartSidebar = () =&gt; {<br>  // We get rich Domain Objects, not just JSON<br>  const { user, cart } = useDomainStore(); <br>  return (<br>    &lt;div&gt;<br>      {cart.isEligibleForVipDelivery(user) &amp;&amp; &lt;SuccessBanner /&gt;}<br>    &lt;/div&gt;<br>  );<br>};</pre><p><strong>2. The React Native Mobile App:</strong></p><p>TypeScript</p><pre>// apps/mobile/src/screens/CheckoutScreen.tsx<br>export const CheckoutScreen = () =&gt; {<br>  const { user, cart } = useDomainStore();<br>  return (<br>    &lt;View&gt;<br>      {cart.isEligibleForVipDelivery(user) &amp;&amp; &lt;Text&gt;VIP Delivery!&lt;/Text&gt;}<br>    &lt;/View&gt;<br>  );<br>};</pre><p><strong>3. Backend Server (Bonus):</strong> Because your domain logic is just TypeScript (no React hooks involved), you can even import this same package into your BFF (Backend for Frontend) or Serverless functions to validate the request before processing it!</p><h3>The Verdict</h3><p>Do you still need DDD in React?</p><p>If you are building a landing page? <strong>No.</strong> If you are building a dashboard where the backend does 100% of the thinking? <strong>No.</strong></p><p>But if you are building a <strong>product</strong> where the interface spans web, mobile, and server environments? <strong>Yes.</strong></p><p>We don’t use DDD in the frontend to make things complex. We use it to decouple our <strong>Business Rules</strong> from the <strong>UI Library</strong>.</p><p>React is just a rendering engine. It will change. useEffect might go away. Signals might take over. But the fact that &quot;Gold Members with $100 carts get VIP delivery&quot; is eternal (until the PM changes it).</p><p>Keep that logic safe. Keep it out of your components.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e3037f9ad1b8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/elementor-engineers/do-we-still-need-ddd-the-quick-feature-that-turned-into-a-weekend-nightmare-e3037f9ad1b8">Do We Still Need DDD? The “Quick Feature” That Turned Into a Weekend Nightmare</a> was originally published in <a href="https://medium.com/elementor-engineers">Elementor Engineers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>