<?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 Rodrigo Vianna Calixto de Oliveira on Medium]]></title>
        <description><![CDATA[Stories by Rodrigo Vianna Calixto de Oliveira on Medium]]></description>
        <link>https://medium.com/@rodrigo.vianna.oliveira?source=rss-8e062bd797cc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jrfhnO3L7TjBH3MHmfS5-g.jpeg</url>
            <title>Stories by Rodrigo Vianna Calixto de Oliveira on Medium</title>
            <link>https://medium.com/@rodrigo.vianna.oliveira?source=rss-8e062bd797cc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 13:29:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rodrigo.vianna.oliveira/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[Demystifying SDD with AI agents: understand the concept before the commands]]></title>
            <link>https://medium.com/codandotv/demystifying-sdd-with-ai-agents-understand-the-concept-before-the-commands-db1be4fa836a?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/db1be4fa836a</guid>
            <category><![CDATA[spec-driven-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Sun, 02 Aug 2026 16:18:59 GMT</pubDate>
            <atom:updated>2026-08-04T15:47:55.041Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZGj1PiUdko4s3G1hVOoD3g.png" /></figure><p>You start studying SDD(Spec Driven Developmet) and this happens:</p><blockquote>`requirements.md`, `proposal.md`, `spec.md`.</blockquote><p>Three different names. Same step.</p><p>🇧🇷 <a href="https://medium.com/codandotv/desmistificando-o-sdd-com-agentes-de-ia-entenda-o-conceito-antes-dos-comandos-ce6d519b460a">Read this article in Portuguese.</a></p><p>Then comes planning. Kiro and OpenSpec call it <strong>design.md</strong>. Spec Kit calls it <strong>plan.md</strong>. Claude Code, Copilot and Gemini don’t generate any file at all, they enter a read-only mode and present the plan for your approval. Same concept, completely different ways of getting there.</p><p>And when it’s time to execute: <strong>/opsx:apply </strong>in OpenSpec, <strong>/speckit.implement</strong> in Spec Kit, <strong>Agent mode</strong> in Copilot.</p><p>Same process. Completely different vocabularies.</p><p>That’s when I stopped trying to memorize and went after the concepts. And once the concept was clear, any tool started to make sense.</p><p>That’s exactly what this article is about: mental model before commands. I’ll use the Mobile context, which is where I live, but the concepts apply to any stack.</p><h4>The problem with learning by framework instead of by concept</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*jsMF75XNIxa3HzqIG2al5g.png" /></figure><p>Imagine someone wants to teach you dependency injection. Instead of explaining the concept (inverting control of dependencies to make code testable and decoupled), they open straight into Hilt or Koin and start showing you how to use <a href="http://twitter.com/HiltAndroidApp"><strong>@HiltAndroidApp</strong></a><strong>, </strong><a href="http://twitter.com/Inject"><strong>@Inject</strong></a><strong>, </strong><a href="http://twitter.com/Module"><strong>@Module</strong></a><strong> or factory, module, qualifier.</strong></p><p>You learn how to use Hilt, but if tomorrow the project migrates to Koin, you’re back to zero. After all, both solve the same problem in very different ways: one is focused on a tree structure, the other on service locator. The concept was never explained.</p><p>With SDD, the same thing happens. Most content teaches OpenSpec, or Spec Kit, or Kiro, and skips the concept. So when you switch tools, or see someone using a different one, it feels like learning everything from scratch, and even the configurations you set up don’t carry over, since these tools generate <strong>.md</strong> files in their own structures.</p><h3>What SDD really is</h3><p>I’ll use <a href="https://github.com/CodandoTV/CraftD"><strong>CraftD</strong></a> as the example throughout this article. It’s an open-source Server Driven UI framework maintained by <a href="https://www.youtube.com/c/CodandoTV"><strong>CodandoTV</strong></a>, with support for Android, iOS, Flutter and KMP. It’s where I applied SDD with <strong>OpenSpec</strong>, both in creating the component structure and in maintaining the project.</p><p>SDD is an approach where you <strong>take the decision out of execution and put it into specification</strong>.</p><p>Or more practically:</p><blockquote>you stop “thinking while coding”<br>and start “coding what’s already been thought through”.</blockquote><p>Instead of opening Claude’s chat and saying “add support for a new component in CraftD”, you first document what needs to be done and why, plan how you’ll do it, break it into atomic tasks, and only then ask the agent to execute.</p><p>The difference isn’t about the tool. It’s about where the <strong>decision happens</strong>.</p><p>This process has two parts. The first is done once, when you configure the project:</p><pre><strong>CONFIGURATION ( Model Initialization File )</strong></pre><p>The second happens with each change. You start from an idea or goal, communicate with the model in natural language (that’s the <strong>exploration</strong> step), then follow the flow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wsw6wEY5I77-q4beTnHDGw.png" /></figure><p>What changes between tools is the name and the file each one uses at each step. Let’s break them down one by one.</p><blockquote>Worth noting: I&#39;m talking about the tools I&#39;ve used or studied. If you use another one, the mapping might be different.</blockquote><h4>Before the layers: exploration</h4><p>Before entering the formal flow, some tools offer an optional exploration step. The idea is simple: you don’t quite know yet what you want to build, you want to think out loud, investigate the problem before formalizing anything.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*90JKoZaIIgZR_KTmHJ_N0Q.png" /></figure><p>This step generates no files. It’s just a mental draft. When you know what you want to build, go straight to specification.</p><p>And here I had a confusion that might help you:<strong> Plan Mode</strong> is not equivalent to <strong>explore</strong>. They’re things from different layers.</p><blockquote><strong>Explore</strong> answers:<br>- what do I want to build?</blockquote><blockquote><strong>Plan Mode</strong> answers:<br>- how am I going to implement this technically?</blockquote><p>Seems subtle, but it’s the difference between discovering the problem and solving the problem.</p><h3>Layer 1: Configuration (Initialization File)</h3><p><strong>The concept: make sure the agent knows the project rules before any task.</strong></p><p>Without this layer, every time you ask the agent for something, it starts from zero. Doesn’t know the architecture, doesn’t know the patterns, doesn’t know what it can and can’t do. You either explain everything in the prompt every time, or hope it guesses right.</p><p>Worth mentioning skills too, which follow the same logic of not starting from scratch. The difference is subtle: configuration is passive — the agent always loads it without you triggering it. Skills are procedures you trigger when needed. What few people know: the agent maps all skill files by reading the<strong> name and description</strong> of each one. When a context or keyword matches what it has mapped, it decides whether to read the entire file or not for that task. That’s how it knows which skill is relevant without you having to say explicitly. That’s also why the model doesn’t guarantee it will always execute skills: if the <strong>name and description</strong> aren’t well mapped, it simply won’t associate.</p><p>Initialization File solves this: you define the rules once, and the agent loads them in every task automatically.</p><p><strong>How the models implement this:</strong></p><p>In Claude Code, you create a file called <strong>CLAUDE.md </strong>at the root of the project. It’s read automatically at the start of every session. No need to reference it, no need to pass it in the prompt. The agent simply loads it. It’s not an SDD convention; it’s how Claude Code works.</p><p>Copilot does the same thing via <strong>.github/copilot-instructions.md</strong>, read automatically through the repository configuration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LkMHSEQheUSscRoPLCsuEA.png" /></figure><p><strong>How Spec Kit formalizes this as an SDD step:</strong></p><p>Spec Kit goes further and turns configuration into an explicit file in the flow: <strong>constitution.md.</strong> Instead of leaving rules implicit, you create this file as the first step of the process, before specifying anything. It’s a tool with a strong opinion about how this should be done.</p><p>The content is the same as what you’d put in <strong>CLAUDE.md</strong>: architecture principles, patterns, constraints. What changes is that in Spec Kit this becomes a formal step, not a background configuration.</p><h4>In the CraftD context** (Server Driven UI library by CodandoTV for Android, iOS, Flutter and KMP):</h4><ul><li>“Platform modules (android, ios, flutter) cannot depend on each other, only on core”</li><li>“Every new component must implement the <strong>CraftDBuilder</strong> abstraction”</li><li>“Fallback behavior via <strong>onAction</strong> must always be covered”</li></ul><p>If it’s something the agent would need to know before any task, it belongs in configuration.</p><h3>Layer 2: Specification</h3><p><strong>The concept: document the what and the why before any code.</strong></p><p>Before planning how to do it, you need to be clear on what you’re going to do and why. This layer answers: what’s the problem? who is affected? what are the success criteria? what are the constraints?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JqEB91Eq1x2YgS4MEvyNdA.png" /></figure><p>Claude Code, Copilot and Gemini don’t have their own specification file. They’re the agents that execute the process, and you layer a framework like OpenSpec or Spec Kit on top.</p><h4>In the CraftD context:</h4><p>Without this layer, you open the chat and say “add a carousel component”. The agent creates something. But in which module? With what acceptance criteria? Integrating with what?</p><p>With this layer, you write: “we need a carousel component because the product team wants to allow multiple banners to be displayed via Server Driven UI without a new app version. Affected modules: android, ios. Success criteria: renders horizontal list of items received from the JSON response.”</p><p>The agent now has enough context to make consistent decisions.</p><blockquote><strong>A question I had in practice</strong>: at the beginning of the flow, I was unsure whether I should run an /opsx:explore before proposing anything. After all, explore exists — why not use it? The answer I landed on: explore is a <strong>thinking partner</strong>, not a mandatory step. It’s for when you’re not sure what you want to build, want to think out loud before formalizing, or are investigating a complex problem. If you already know what you want, go straight to /opsx:propose. Explore is the mental draft, not step 1 of the process.</blockquote><h3>Layer 3: Planning</h3><p><strong>The concept: document the how, its means, the technical implementation decisions.</strong></p><p>With the what and why defined, this layer answers: how is it going to be done? Which abstractions to use? Which modules are affected? What’s the logical sequence?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*McapswqF5In46ERopiA24A.png" /></figure><p>The <strong>Plan Mode</strong> in Claude Code, Copilot, and Gemini are the most different here: instead of generating a file, they enter a read-only analysis mode. They investigate the codebase, formulate a plan, and present it for approval before touching anything.</p><p>Useful for quick validation. But without a saved file, the plan isn’t trackable and doesn’t automatically feed into the next steps.</p><p>And to make the point I mentioned earlier clear: <strong>Plan Mode</strong> belongs in this layer, not in pre-exploration. OpenSpec’s <strong>explore</strong> answers “what do I want to build?”. <strong>Plan Mode </strong>answers “how am I going to build this technically?”</p><p>Seems subtle, but the timing difference is huge: exploration happens before any file, planning happens after the specification is already defined.</p><blockquote><strong>I have a question:</strong> once I wondered if /opsx:explore only worked for projects that already had code. After all, explore investigates the codebase, right? Wrong. Explore works as a thinking partner in any context. In a repo from scratch, it helps you think about structure, flow, decisions you haven’t made yet. Investigating code is just one of the things it does.</blockquote><h3>Layer 4: Break into tasks</h3><p><strong>The concept: break the plan into independent, executable tasks.</strong></p><p>This is the most consistent layer across all tools. All of them call it tasks; all use <strong>tasks.md. A</strong>ll follow the same principle: each task should be small enough to be executed and verified in isolation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OxQVYDMrWS5tjw2z34yPOA.png" /></figure><blockquote><strong>Worth mentioning</strong>: independent tasks open the door to the Multi Agents universe. You can have a planner agent to analyze and distribute tasks among N agents in parallel, and another agent responsible for reviewing and documenting the result.</blockquote><h3>Layer 5: Execution</h3><p><strong>The concept: the agent comes on stage as executor, with all the context already structured in the previous layers. Think of it as a collaborator: you fully handed over the context, explained the problem, the plan, the tasks. Now just delegate and let it execute.</strong></p><p>This is the layer where almost everyone breaks the process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*4R8ja_5_tSputYoxQPDglg.gif" /></figure><p>You went through the previous layers, created the files for each step, and have all the context structured, but when the moment of truth comes, you open the chat and say “hey, implement this feature”. The process was right, but at execution you went back to winging it.</p><p>And that’s when you lose exactly the benefit of SDD.</p><p>In practice this turns into:</p><ul><li>code inconsistent with what was planned</li><li>decisions being remade during execution</li><li>dependency on prompt instead of process</li></ul><p>In other words: you went back to square one without realizing it.</p><p>Execution within SDD isn’t opening an empty chat. It’s triggering the agent pointing to the directory you built in the previous steps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N7SWLDIMgu3_zY5W9ejHvw.png" /></figure><p><strong>The framework organizes the process. The agent executes the process.</strong></p><p>Example:</p><p>OpenSpec is the script. Claude is the actor that follows the script. When you run<strong> /opsx:apply</strong>, you’re telling Claude: “read the files we prepared and execute”. Claude isn’t the orchestrator. You are.</p><blockquote><strong>Worth mentioning:</strong> /opsx:archive in OpenSpec isn’t just moving the change to a done directory. It merges the change’s specs with the project’s existing specs. In practice it may not make a difference day to day, but it’s up to you to evaluate whether it’s useful for project documentation. That means on the next /opsx:propose, the agent already has context from what was done before: impacts, decisions, changes. The history becomes input for the next specification.</blockquote><blockquote><strong>A question I had in practice:</strong> when I used OpenSpec for the first time, I tried running /opsx:apply directly in the terminal. Error. I spent a while trying to understand what was wrong, until I realized that slash commands work inside the IDE — either as a prompt in Copilot or as commands in Claude. If you want to trigger OpenSpec directly from the terminal, the command is different: openspec-apply-change. Each tool has its own way of being called. Seems obvious once you get it, but nobody makes this clear upfront.</blockquote><h3>The complete flow side by side</h3><p>To wrap up, the flow of each tool translated into the concepts:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JuODJJFo3vxXVZ2qk7QuGQ.png" /></figure><p>When you come across new content about any of these tools — or any other that will emerge — try to map what’s being shown to one of these layers. The name will be different. The concept will be the same.</p><h3>Wrapping up</h3><p>The mistake I made, and I believe many people make, was trying to learn SDD by memorizing the commands and file names to absorb it quickly ‘in practice’ before understanding why each layer exists.</p><p>Configuration (initialization file), specification, planning, breaking into tasks and execution are tool-independent concepts. It’s the same confusion as learning Koin without understanding dependency injection — works until the day you need to switch frameworks.</p><p>With the mental model clear, you can pick up any tool (OpenSpec, Spec Kit, Kiro, whatever comes next) and map it to the layers. The name will be different. The concept will be the same.</p><p>If you’re just getting started, try answering these questions before creating any file:</p><ul><li>What does my agent always need to know? Configuration layer.</li><li>What and why am I building? Specification layer.</li><li>How am I going to build it? Planning layer.</li><li>What are the atomic tasks? Break into tasks layer.</li><li>How do I trigger the agent with all this context? Execution layer.</li></ul><p>If you can answer that, you no longer depend on the tool.</p><p>You just choose which one to use.</p><p><strong>This article is part of a series on development with AI agents we’re doing at CodandoTV.</strong></p><p>All of this was applied to <a href="https://github.com/CodandoTV/CraftD">CraftD</a> using Claude+OpenSpec, along with other concepts like `Single Source of Truth`, and soon other CodandoTV repositories will also explore other tools.</p><p>Any questions or suggestions? Find me on <a href="https://www.linkedin.com/in/rviannaoliveira/">LinkedIn</a> or on <a href="https://codandotv.com/">CodandoTV</a>.</p><p>And there’s still a lot more to explore. The SDD we covered here is one piece. But there are skills, MCP, multi-agent orchestration, and how all of that connects into a bigger concept called <strong>harness</strong>: the complete infrastructure you build around the agent so it operates well in your project. It’s not just context. It’s context + tools + ability to act.</p><p>But let’s start by lighting a candle before throwing a fireball!</p><p>🔥🔥🔥</p><p>That’s all folks!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db1be4fa836a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/demystifying-sdd-with-ai-agents-understand-the-concept-before-the-commands-db1be4fa836a">Demystifying SDD with AI agents: understand the concept before the commands</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AGENTS.md: a Single Source of Truth wasn’t enough]]></title>
            <link>https://medium.com/codandotv/agents-md-a-single-source-wasnt-enough-9c6ede2b823b?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c6ede2b823b</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Sun, 02 Aug 2026 15:25:26 GMT</pubDate>
            <atom:updated>2026-08-02T15:49:15.260Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4muXNqqwBTq0kGOGVdTyHA.png" /></figure><p>I was presenting a skills centralization I had implemented months earlier when someone asked:</p><blockquote>“Why do we have `.github/prompts/` with 4 large files?”</blockquote><p>That question hit right where it hurt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*0-EDJXze6it7Lw7ukdehLw.gif" /></figure><p>If you read Part 1 [<a href="https://medium.com/codandotv/agents-md-a-single-source-of-truth-for-any-ai-in-your-repo-ce1d0d7ea918">AGENTS.md: a Single Source of Truth for Any AI in Your Repo</a>], you know I’ve been centralizing all AI context in <strong>AGENTS.md</strong>, turning the native files of each tool (Copilot, Claude, Kiro, everything in the same repo) into one-line pointers inside a main folder called <strong>`ai/`</strong>. It worked. But this time I realized the pattern didn’t cover everything.</p><p>I started thinking: shouldn’t the OpenSpec also be centralized? And the Kiro files? How had I forgotten them?</p><p>I had implemented the centralization months earlier, but focused on the context files. The OpenSpec skills, the Kiro prompts, the adaptations I had to make so Claude wouldn’t lose the <strong>`/skills` </strong>commands from OpenSpec… I had let those slip.</p><h4>The pattern I had established</h4><p>After centralization, the structure looked something like this:</p><pre>AGENTS.md                          ← everything any AI needs to know<br>CLAUDE.md                          ← &quot;read AGENTS.md&quot;<br>.github/copilot-instructions.md    ← &quot;read AGENTS.md&quot;<br>.kiro/steering                     ← &quot;read AGENTS.md&quot;<br><br>ai/<br>├── instructions/<br>│   ├── instructions.md<br>│   └── code-review.md<br>└── skills/<br>    ├── android-architecture/SKILL.md<br>    ├── openspec-propose/SKILL.md<br>    └── ... (skills)</pre><p>The OpenSpec skills lived in<strong> `ai/skills/`</strong>. Copilot used <strong>`.github/skills/`</strong>, Claude used <strong>`.claude/skills`</strong>, all pointers pointing to<strong> `ai/skills/`</strong>. All good.</p><h4>The discovery</h4><p>I went to check what was in `.github/prompts/` (keeping in mind I’m using OpenSpec as an example, but this can happen with any other framework — the files with the `opsx-` prefix are generated by OpenSpec itself during initial setup):</p><pre>$ ls -lh .github/prompts/<br>-rw-r--r--  1 user  staff  8.2K  opsx-propose.prompt.md<br>-rw-r--r--  1 user  staff  7.9K  opsx-apply-change.prompt.md<br>-rw-r--r--  1 user  staff  8.1K  opsx-explore.prompt.md<br>-rw-r--r--  1 user  staff  8.3K  opsx-archive-change.prompt.md<br><br>//Four files. 32 KB total.</pre><p>I opened one:</p><pre>--<br>description: Propose a new change - create it and generate all artifacts in one step<br>---<br><br># openspec-propose Skill<br><br>Propose a new change - create the change directory and generate all artifacts in one step.<br><br>Artifacts created:<br>- `proposal.md` - What and why (in Portuguese)<br>- `design.md` - How to implement, architecture (in Portuguese)<br>- `tasks.md` - Implementable technical tasks (in English)</pre><p>Suspicious. This looked familiar. I compared it with <strong>`ai/skills/openspec-propose/SKILL.md`</strong>.</p><p>Exact copy. And the worst part: someone who didn’t know the structure could walk right past it, configure a new tool in the wrong place, and create yet another parallel copy without ever knowing the source of truth was somewhere else.</p><h4>Why did this exist?</h4><p>GitHub Copilot has a feature called Prompt Files: files in <strong>`.github/prompts/`</strong> that it automatically discovers in VS Code and the extension. Someone had copied the files from <strong>`ai/skills/`</strong> there so Copilot could find them. Makes sense as an idea. The problem is it created silent duplication.</p><p>The situation before any fix:</p><pre>ai/skills/openspec-propose/SKILL.md  ← SOURCE OF TRUTH<br><br>Copilot (skills)   → .github/skills/openspec-propose/   → POINTER  ✅<br>Copilot (prompts)  → .github/prompts/opsx-propose.md    → COPY     ❌<br><br>Claude (skills)    → .claude/skills/openspec-propose/   → POINTER  ✅<br>Claude (commands)  → .claude/commands/opsx-propose.md   → COPY     ❌<br><br>Kiro (skills)      → .kiro/skills/openspec-propose/     → POINTER  ✅<br>Kiro (prompts)     → .kiro/prompts/opsx-propose.md      → COPY     ❌<br>Kiro (steering)    → .kiro/steering.md                  → COPY     ❌</pre><p>Seven files. Three were already pointers. Four were copies. When someone edited the skill in <strong>`ai/skills/`</strong>, the skills side saw the change. Copilot prompts, Claude commands, Kiro prompts, and the init files kept the old version. Nobody knew.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*I98jpzHUnfxdVbISSfjV7w.gif" /></figure><blockquote><strong>In practice, check your own scenario</strong><br><br>Using Copilot? Check `.github/prompts/`. Using Kiro? Check `.kiro/prompts/` and `.kiro/steering.md`. Using Claude? Check `.claude/commands/`. The pattern of creating copies when setting up a new tool is the same across all of them.</blockquote><h4>Three options on the table</h4><p>When I analyzed the problem, I had three paths:</p><p><strong>Option 1: delete `.github/prompts/`</strong></p><p>Simple. Removes the duplication entirely. But depending on the moment, you don’t know if someone or some workflow depends on those files. Deleting without knowing the impact is risky. Rejected.</p><p><strong>Option 2: move to `ai/prompts/`</strong></p><p>Semantically cleaner. Separate prompts from skills inside <strong>`ai/`</strong>. But the OpenSpec CLI expects the structure that’s in <strong>`ai/skills/`</strong>. Changing it would break the OpenSpec workflow. More refactoring, more risk. Rejected.</p><p><strong>Option 3: convert to pointers</strong></p><p>Turn each 104-line file into 3 lines. Same as what I did with<strong> `CLAUDE.md`</strong> and friends in Part 1.</p><p>Looks like a hack? A little. Technically, a file in <strong>`.github/prompts/`</strong> that points to something in <strong>`ai/skills/`</strong> mixes concepts. But it’s non-breaking, simple, and solves the problem now. Approved.</p><blockquote><strong>Something that confused me in practice</strong><br><br>“Why not move `<strong>ai</strong>/skills/openspec-*/` to `<strong>ai</strong>/prompts/opsx-*/` and clean it up once and for all?”<br><br>Because OpenSpec is an external framework. Its CLI expects the structure that’s in `<strong>ai</strong>/skills/`. Touching that without knowing exactly how OpenSpec reads the internal `config.yaml` is asking for something to break silently. The pragmatic solution is to leave the source of truth where it is and just redirect the copies.</blockquote><h4>The implementation</h4><p>Each file in<strong> `.github/prompts/`</strong> went from 104 lines to 3:</p><p>Before:</p><pre>---<br>description: Propose a new change - create it and generate all artifacts in one step<br>---<br><br># openspec-propose Skill With Many Stuffs</pre><p>After:</p><pre>---<br>description: Archive a change after all tasks are complete<br>---<br><br>&gt; **OpenSpec prompts have been centralized in `ai/skills/`**<br>&gt;<br>&gt; Read the full version at: [`ai/skills/openspec-archive-change/SKILL.md`](../../ai/skills/openspec-archive-change/SKILL.md)<br><br>See **`AGENTS.md`** at repo root for full AI context and OpenSpec workflow.</pre><p>Each tool has its own discovery locations:<strong> `skills`</strong>,<strong> `prompts`</strong> or <strong>`commands`</strong>, and an init file. For Copilot it’s <strong>`skills</strong>` and <strong>`prompts</strong>`. For Claude it’s `skills` and `commands`. For Kiro it’s <strong>`skills`</strong>, <strong>`prompts`</strong>, and <strong>`steering.md`</strong>. Each one became a pointer to the same destination.</p><p>Using Kiro as an example, the three looked like this:</p><pre>`.kiro/prompts/opsx-explore.prompt.md`:<br><br><br>---<br>description: Explore ideas and investigate problems before proposing a change<br>---<br><br>&gt; **OpenSpec prompts have been centralized in `ai/skills/`**<br>&gt;<br>&gt; Read the full version at: [`ai/skills/openspec-explore/SKILL.md`](../../ai/skills/openspec-explore/SKILL.md)<br><br>See **`AGENTS.md`** at repo root for full AI context and OpenSpec workflow.<br></pre><pre>`.kiro/skills/openspec-explore/SKILL.md`:<br><br><br>---<br>name: openspec-explore<br>description: Use as a thinking partner to explore ideas, clarify requirements, or investigate problems before proposing a change.<br>---<br><br>&gt; **This skill has been centralized in `ai/skills/`**<br>&gt;<br>&gt; Read the full version at: [`ai/skills/openspec-explore/SKILL.md`](../../../ai/skills/openspec-explore/SKILL.md)<br><br>Your Kiro discovers this file automatically. The real content is in `ai/skills/` — the single source of truth for all AI tools (Copilot CLI, Claude, Cursor, Kiro).<br></pre><pre>`.kiro/steering.md`:<br><br><br>**Kiro context has been centralized in `AGENTS.md`**<br>See **`AGENTS.md`** at repo root for full AI context, patterns, and architecture rules.</pre><p>Three different files, same destination.</p><p>The result in numbers:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mJzDRmLC7fC8Rfw3BpHBeA.png" /></figure><p>Total: 92 KB of duplication removed. Zero breaking changes.</p><h4><strong>The four decisions that mattered</strong></h4><p>Looking back, four choices made the difference.</p><p>The first was using a pointer instead of deleting. I didn’t know who was using <strong>`.github/prompts/`</strong>. A pointer keeps everything working while removing the duplication. If someone depends on the file, they still find it; it just redirects to the source of truth now.</p><p>The second was not touching <strong>`ai/skills/openspec-*/`</strong>. The OpenSpec CLI expects that structure. Changing it without documentation is a risk not worth the cleaner semantics.</p><p>The third was pulling tooling metadata out of AGENTS.md. Where each tool looks for its files is information for devs, not project context for AI. It went to <strong>`README-AI-CONTEXT.md`</strong>. AGENTS.md kept what’s its: project context.</p><p>The fourth was testing with a real change. After converting the files, I ran a complete OpenSpec flow to confirm the pointer chain worked end to end , not just that the files existed.</p><p><strong>Wrapping up</strong></p><p>The pattern from Part 1 solves the problem of having different rules in each tool’s native file. But new tools keep coming, and each one has its preferred folder. Copilot has <strong>`.github/prompts/`</strong>. Claude has <strong>`.claude/commands/`</strong>. Kiro has <strong>`.kiro/prompts/`</strong> and <strong>`.kiro/steering.md`</strong>. The tendency is to copy and forget.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*Hrd-dZBDSICm3g-NVNQc0w.gif" /></figure><p>The solution doesn’t change: when a copy shows up, turn it into a pointer. Maintenance work stays in one place. That said, I recommend setting up a <strong>`CODEOWNERS` </strong>for these folders. It’s easy to lose track when a new tool or integration gets added.</p><p>A single source of truth isn’t just about choosing where the content lives. It’s also about controlling every place each tool expects to find it.</p><p>If you haven’t read how I got to this structure, start with Part 1: <a href="https://medium.com/codandotv/agents-md-a-single-source-of-truth-for-any-ai-in-your-repo-ce1d0d7ea918">AGENTS.md: a single source of truth for any AI in your repository</a></p><p>My next step is to explore skill references by URL. The idea is to allow certain patterns to be shared across projects without having to duplicate the entire structure in each repository.</p><p>Got questions about implementing this in your project? Drop them in the comments. And if you want to see a real example, <a href="https://github.com/CodandoTV/CraftD">CraftD</a> and other repos from <a href="https://github.com/CodandoTV">CodandoTV</a> already have this single source of truth structure in place for the skills.</p><p>That’s it Folks!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c6ede2b823b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/agents-md-a-single-source-wasnt-enough-9c6ede2b823b">AGENTS.md: a Single Source of Truth wasn’t enough</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AGENTS.md: a Single Source of Truth for Any AI in Your Repo]]></title>
            <link>https://medium.com/codandotv/agents-md-a-single-source-of-truth-for-any-ai-in-your-repo-ce1d0d7ea918?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce1d0d7ea918</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Fri, 19 Jun 2026 17:35:27 GMT</pubDate>
            <atom:updated>2026-08-04T14:33:38.813Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EmPKHRUbkiuW9Pu-BlD9Qw.png" /></figure><p>You use Claude Code. Your teammate prefers Copilot. The repo has a `CLAUDE.md` and a `.github/copilot-instructions.md`. So far so good.</p><p>Then comes the update. You changed the module naming convention. You update `CLAUDE.md`. Forget `copilot-instructions.md`. Create a new skill in `.claude/skill/`. Don’t replicate it in `.github/`. Two weeks later, your teammate opens VS Code, gets suggestions with the old convention, and has no access to the skill. Nobody notices right away.</p><p>Doesn’t have to be a big team. Just you using two AI coding assistants on the same project. Claude Code in the morning, Copilot in VS Code in the afternoon. Each one reading its own file. Each one with a different view of the project.</p><p>Or token budget. You have your Claude plan up to a monthly limit, and Kiro paid to fill the gap. When one runs out, you switch to the other. Same repo. Two agents. Each one with a different version of your rules.</p><p>I started feeling this in two places. At work, the company has multiple agents available, and we end up using more than one depending on the context. Each with its own file. Each learning a different version of the project. In the CodandoTV repos, it’s open source: different people can open PRs, each with whatever assistant they prefer, and I won’t even know which one.</p><p>And it doesn’t stop at context. Skills too. In Claude, they live in `.claude/skills/`. In Copilot, in `.github/skills`. Each AI coding assistant has its own folder, its own format, its own convention. The same skill implemented twice, in both places. Or only in one place, leaving half the team without access.</p><p>The problem isn’t the AI coding assistants. It’s that each one invented its own init file, its own skills folder, its own format.</p><p>So the question is: how do you make sure any AI coding assistant starts from the same context? No matter which one the contributor or you is using.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*ZHdn0GTKSaK9v-jWVAZ_-A.gif" /></figure><h3>There’s already a standard for this</h3><p>The answer is `AGENTS.md`.</p><p><a href="https://github.com/openai/agents.md">OpenAI</a> introduced this convention for coding agent instructions. <a href="https://github.blog/ai-and-ml/github-copilot/how-to-write-a-great-agents-md-lessons-from-over-2500-repositories/">GitHub already documents the standard</a>. When you put an `AGENTS.md` at the root of the repo, any dev who opens it immediately understands what it is, no explanation needed. It’s not specific to any AI coding assistant. It’s neutral by design.</p><p>That’s exactly what we needed.</p><blockquote><strong>Something that confused me in practice</strong><br><br>“But isn’t AGENTS.md natively supported by all AI coding assistants?”<br><br>Not yet. Claude reads `CLAUDE.md`, Cursor reads `.cursorrules`. But here’s the trick: `AGENTS.md` doesn’t need to replace the native files. It becomes the content. The others become pointers. Each assistant keeps reading its own file, but that file now just says “context is in AGENTS.md”. If the assistant follows the redirect, great. If not, it still knows the name and purpose of the project.</blockquote><h3>The solution</h3><p>`AGENTS.md` becomes the master initializer. One file with everything any AI needs to know: what the project is, module structure, architectural rules, how to implement tasks, how to do reviews.</p><p>That’s what we did in CraftD, a multi-platform open-source project (Android, iOS, Flutter) from the <a href="https://github.com/CodandoTV">CodandoTV</a> channel. <a href="https://github.com/CodandoTV/CraftD/pull/112">That PR shows</a> the full migration: before, each AI coding assistant had its own content. After, they became pointers.</p><p>Each native file becomes a minimal redirect. No content of its own. For example:</p><pre><br>📄 AGENTS.md                        ← single source of truth<br>📄 CLAUDE.md                        ← &quot;read AGENTS.md&quot;<br>📄 .github/copilot-instructions.md  ← &quot;read AGENTS.md&quot;<br>📄 .cursorrules                     ← &quot;read AGENTS.md&quot;<br>📄 .gemini/context.md               ← &quot;read AGENTS.md&quot;<br>📄 README-AI-CONTEXT.md             ← explains the structure to humans<br>📁 ai/<br>    📄 module-graph.md<br>    📁 instructions/<br>        📄 android.md<br>        📄 ios.md<br>        📄 flutter.md<br>    📁 skills/<br>        📁 new-component<br>          📄 SKILL.md<br>        📁 review-pr<br>          📄 SKILL.md<br>        📁 run-build<br>          📄 SKILL.md<br>        📁android-gradle-logic<br>          📄 SKILL.md</pre><p>There are also other ways to evolve this solution, as <a href="https://medium.com/u/3c01aab19b51">Gabriel Bronzatti Moro</a> clearly explained in this <a href="https://medium.com/codandotv/getting-started-with-spec-driven-development-e72302868eb5">article</a>.</p><h3>Why each piece exists</h3><p>Looks like a lot. But each piece has a reason to exist.</p><p><strong>AGENTS.md </strong>is the only file we maintain. It has everything any AI needs to know to work on the project. I chose it because it’s an existing convention. Any dev who opens the repo already understands the purpose without having to ask.</p><p><strong>CLAUDE.md, .cursorrules, copilot-instructions.md, gemini/context.md</strong> exist because each AI coding assistant has its own native init file. Can’t remove them. But instead of duplicating content, they became one-line pointers. They identify the project and redirect to `AGENTS.md`.</p><p><strong>ai/</strong> holds detailed context that would be too heavy for `AGENTS.md`. Split by platform and task type. `AGENTS.md` references the folder, not individual files. New skill? Create the file inside `ai/skills/`. No need to touch `AGENTS.md`.</p><p>Some AI coding assistants let you configure where skills live. OpenCode, for example, has an `opencode.json` where you set the path. In<a href="https://github.com/CodandoTV/eagle-eye/pull/35"> eagle-eye, there is a PR</a> that we migrated from `.opencode/skills/` to `ai/skills/` with one line:</p><pre>{<br>  &quot;$schema&quot;: &quot;https://opencode.ai/config.json&quot;,<br>  &quot;instructions&quot;: [&quot;AGENTS.md&quot;],<br>  &quot;skills&quot;: {<br>    &quot;paths&quot;: [&quot;ai/skills&quot;]<br>  }<br>}</pre><p>The `/skill` shortcuts in the prompt keep working. They now point to the centralized place, not to each assistant’s exclusive folder.</p><p><strong>README-AI-CONTEXT.md </strong>isn’t for AI. It’s for humans. Any contributor who wonders “why are there so many AI config files here?” finds the answer in one place.</p><h3>Three decisions that make the difference.</h3><ul><li><strong>Critical rules only in AGENTS.md -</strong> Not in any native file. That way every contributor gets the same rules, no matter which AI coding assistant they use.</li><li><strong>Skills referenced by folder, not by file -</strong>`AGENTS.md` points to `ai/skills/`, not `ai/skills/new-component.md`. New skill? Create the file. No need to touch `AGENTS.md`.</li><li><strong>Native files with no content of their own - </strong>This eliminates divergence at the root, not the symptom. The temptation is to put “just this one detail” in `CLAUDE.md`. Don’t. When a file has its own content, it will diverge. It’s just a matter of time.</li></ul><h3>Wrapping up</h3><p>Doesn’t matter if the team migrated from Claude to Copilot. If a contributor uses Cursor. If the company adopted Kiro last week. Everyone starts from the same context. No duplicated maintenance. No silent divergence.</p><p>It’s not a universal convention yet. Some AI coding assistants follow the redirect natively; others need you to configure it. But the principle works today: one file to maintain, N tools using the same context.</p><p>If you already have a `CLAUDE.md`, `.cursorrules`, or `.github/copilot-instructions.md` in your project, the path is straightforward:</p><p>1. Create `AGENTS.md` with the content you already have<br>2. Turn the native file into a one-line redirect<br>3. Add `README-AI-CONTEXT.md` for whoever comes next</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*HOC2pwpMN4MbuBeY5_O8wQ.gif" /></figure><p>To make it even easier, I asked Claude to generate a prompt that sets up this whole structure from scratch in any repo. Paste it into your favorite agent, and it’ll do the work:<a href="https://gist.github.com/rviannaoliveira/1a89e2ccdfa3a3ffec2905166f3f007d"> Prompt available here</a>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6716e3ac6d40e4ffdaecf46458abf0e8/href">https://medium.com/media/6716e3ac6d40e4ffdaecf46458abf0e8/href</a></iframe><p>Have you done this in your project? How did it go? Drop a comment</p><p>There were more challenges that I had to continue with and explain in <a href="https://medium.com/codandotv/agents-md-a-single-source-wasnt-enough-9c6ede2b823b">Part 2.</a></p><p>I’d love to know how other teams are solving this.</p><p>That’s all, folks!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce1d0d7ea918" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/agents-md-a-single-source-of-truth-for-any-ai-in-your-repo-ce1d0d7ea918">AGENTS.md: a Single Source of Truth for Any AI in Your Repo</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Does Caveman Actually Save Tokens? I Built a Benchmark to Find Out]]></title>
            <link>https://medium.com/codandotv/does-caveman-actually-save-tokens-i-built-a-benchmark-to-find-out-469c8047c75d?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/469c8047c75d</guid>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[man-cave]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Tue, 05 May 2026 13:55:00 GMT</pubDate>
            <atom:updated>2026-05-05T19:03:53.572Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X2GlKR8wkDJcvhi9CWsflQ.png" /></figure><p>It all started with a video I was going to record for <a href="https://www.youtube.com/@CodandoTV">CodandoTV</a> about <a href="https://github.com/JuliusBrussee/caveman">Caveman</a>.</p><p>The original idea was simple: show how to install it, how to use it, the basics. But over the course of a week I’d been testing it and something felt off: I didn’t feel like I was saving anything in shorter sessions. I was using it because the repo was already consolidated and everyone was talking about it. Before recording I went to test it on my machine to get real examples. And that’s when the problem started.</p><p>The numbers weren’t matching what I expected.</p><p>I thought it was my mistake. I ran the tests again. The results kept being inconsistent. Every new example I tried made me more confused, to the point where I thought I was seeing things. But I kept taking notes, repeating, consolidating, until things started to make sense.</p><p>What I found is that the question I wasn’t even asking was the most important one:</p><p>Is a smaller response the same as a smaller context?</p><p>Claude Code doesn’t just store the final response. It accumulates file reads, tool usage, skills, plugins, messages, and repository analysis. So even if Caveman cuts response verbosity, the real cost of the session might stay the same.</p><p>That’s when the video became a study.</p><p>The main question was:</p><blockquote>Does Caveman really reduce token usage, or does it mostly reduce response verbosity?</blockquote><h3>Methodology</h3><p>This isn’t a scientific benchmark.</p><p>For each scenario, the flow was:</p><pre>1. Start a new Claude Code session<br>2. Run /context to capture the initial state<br>3. Send prompt 1<br>4. Run /context<br>5. Send prompt 2<br>6. Run /context<br>7. Repeat until the end of the prompt set</pre><p>The goal was to measure how context evolved after each prompt, not just the final result.</p><p>Two values were tracked in each test:</p><p>- <strong>Total context</strong>: the full context reported by Claude Code.<br>- <strong>Messages</strong>: the conversation/message portion of the context.</p><p>One important detail: some sessions didn’t start with an empty context. Enabling Caveman and loading its plugins and skills already adds initial overhead. In several runs, the message value was already around 2,500 to 2,600 tokens before the first real test prompt.</p><p>So read the results as a real-world usage comparison, not a perfectly isolated benchmark. The goal was to observe how context grows in real Claude Code sessions, including the overhead from plugins, skills, and setup steps.</p><h3>Prompts used</h3><p>Two prompt groups were used: random questions and code questions.</p><p><strong>Random questions</strong> simulate general questions any user might ask:</p><pre>- How does sleep work? Why do we need to sleep?<br>- How does human memory work? Why do we forget things?<br>- Why is the sky blue during the day and orange/red at sunset?<br>- How does a vaccine work? Why does it protect against diseases?<br>- Why do we feel hungry? How does the body know it needs food?<br>- How does gravity work? Why do objects fall?</pre><p><strong>Code questions</strong> simulate repository analysis and code review inside a real project. I used the <a href="https://github.com/CodandoTV/StreamPlayerApp">Project Netflix-Android</a> from CodandoTV as the base:</p><pre>- Why can the app be slow when loading the stream list?<br>- How can I make sure the search state doesn&#39;t leak across different Activity lifecycle cycles?<br>- Why can the search return outdated results after the user types quickly?<br>- Do a code review of the `ListStreamsScreen.kt` class</pre><p>The same prompts were used in Portuguese and English in the comparative scenarios.</p><p>If you find any issues with the methodology, have suggestions for better scenarios, or want to reproduce the experiment, all session files are available in the repository below — feel free to open an issue.</p><p>Note: this study was conducted on May 3, 2026. Libraries in this space evolve fast, So results may change over time.</p><h3>1. Code Questions: No Caveman vs Caveman Full</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f0msqtb5aahpkC2kQo8eXg.png" /></figure><p>Related logs:</p><ul><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/code-questions-pt-cave-off.txt">data/code-questions-pt-cave-off.txt</a></li><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/code-questions-pt-cave-full.txt">data/code-questions-pt-cave-full.txt</a></li></ul><p>Caveman full <strong>increased</strong> context usage here, it didn’t reduce it. Final context went from 33.7k to 40.2k, a difference of +6.5k tokens.</p><p>It makes sense when you think about it: in code tasks, most of the cost comes from Claude Code’s own behavior — file reads, tool usage, repository analysis. Caveman doesn’t touch any of that. It only acts on the final response, which here is a small fraction of the total.</p><h3>2. Random Questions: No Caveman vs Caveman Full</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7H8C_cf9V_aXNUttsdeMEQ.png" /></figure><p>Related logs:</p><ul><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/random-questions-pt-cave-off.txt">data/random-questions-pt-cave-off.txt</a></li><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/random-questions-pt-cave-full.txt">data/random-questions-pt-cave-full.txt</a></li></ul><p>Here Caveman did help, but modestly: context went from 27.7k to 27.4k. Small, but in the right direction.</p><p>When there’s no file reading or tools involved, the main cost is the response itself. That’s where cutting verbosity actually makes a difference.</p><h3>3. Code Questions: Portuguese vs English with Caveman Full</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U5XzHRTodsfifqv87wX8Xg.png" /></figure><p>Related logs:</p><ul><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/code-questions-pt-cave-full.txt">data/code-questions-pt-cave-full.txt</a></li><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/code-questions-en-cave-full.txt">data/code-questions-en-cave-full.txt</a></li></ul><p>English performed better here: final context dropped from 40.2k to 35.2k. This wasn’t a variable I planned to test, but it became one of the most interesting findings.</p><p><strong>Something that confused me in practice:</strong> does the prompt language actually affect cost? In code tasks, it seems like it does. The model appears to process English more efficiently in this context. But the next scenario goes against that logic.</p><h3>4. Random Questions: Portuguese vs English with Caveman Full</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1lryhV4Obwa9_lepRDfdwg.png" /></figure><p>Related logs:</p><ul><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/random-questions-pt-cave-full.txt">data/random-questions-pt-cave-full.txt</a></li><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/random-questions-en-cave-full.txt">data/random-questions-en-cave-full.txt</a></li></ul><p>English didn’t help here. Context went from 27.4k to 29.0k — it actually got slightly worse. So the English advantage isn’t universal: it seems specific to code tasks, probably because the repository and files are also in English.</p><h4>5. Code Questions: Caveman Full vs Ultra</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yl-xZHlsbk5UhFZcyZVXDg.png" /><figcaption>original link <a href="https://raw.githubusercontent.com/CodandoTV/awesome-ai-coding-assistants-playbook/main/studies/caveman-token-usage-benchmark/image/code-questions-en-cave-ultra.png">https://raw.githubusercontent.com/CodandoTV/awesome-ai-coding-assistants-playbook/main/studies/caveman-token-usage-benchmark/image/code-questions-en-cave-ultra.png</a></figcaption></figure><p>Related logs:</p><ul><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/code-questions-en-cave-full.txt">data/code-questions-en-cave-full.tx</a>t</li><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/code-questions-en-cave-ultra.txt">data/code-questions-en-cave-ultra.txt</a></li></ul><p>Ultra mode didn’t reduce usage compared to full: context went from 35.2k to 38.8k. More restriction on the response doesn’t mean less context spent.</p><h3>6. Random Questions: Caveman Full vs Ultra</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XL0kKLpFVtiuGozqInV4Og.png" /><figcaption>original link <a href="https://raw.githubusercontent.com/CodandoTV/awesome-ai-coding-assistants-playbook/main/studies/caveman-token-usage-benchmark/image/random-questions-en-cave-ultra.png">https://raw.githubusercontent.com/CodandoTV/awesome-ai-coding-assistants-playbook/main/studies/caveman-token-usage-benchmark/image/random-questions-en-cave-ultra.png</a></figcaption></figure><p>Related logs:</p><ul><li><a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/random-questions-en-cave-full.txt">data/random-questions-en-cave-full.txt</a></li><li>data/ra<a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/blob/main/studies/caveman-token-usage-benchmark/data/random-questions-en-cave-ultra.txt">ndom-questions-en-cave-ultra.txt</a></li></ul><p>Same result. Ultra mode went from 29.0k to 29.8k. It wasn’t cheaper than full in any of the tested scenarios.</p><h3>What I Learned</h3><ul><li>Starting a session with Caveman already comes with a high initial messages cost: on my machine, with my setup, it was around 2.5k to 2.6k tokens. Without Caveman, it was only 8 tokens. That alone made me question whether it’s worth using for short sessions.</li><li>In code tasks, Caveman can actually increase total context, not just leave it unchanged. The cost comes from Claude Code itself: tools, file reads, repository analysis. Caveman doesn’t act on that part.</li><li>In random questions, with no tools involved, Caveman helps slightly. When the main cost is the response, cutting verbosity makes a difference.</li><li>English helped in code tasks but not in random questions. It’s not a universal rule, and it’s probably related to the fact that the repository and files are also in English.</li><li>Ultra mode wasn’t more efficient than full in any scenario.</li><li>The initial overhead from plugins and skills is part of the real cost of using Caveman. That needs to be factored in.</li></ul><h3>Conclusion</h3><p>Caveman is useful for changing response style and reducing noise. But don’t treat it as a guaranteed token saver, especially in short sessions. In descriptive conversations, the gain became more noticeable as the session progressed. In code tasks, that didn’t happen.</p><p>For code tasks inside Claude Code, reducing verbosity is not the same as reducing the real cost of the session. They’re different things.</p><p>The full logs and images from the study are in the <a href="https://github.com/CodandoTV/awesome-ai-coding-assistants-playbook/tree/main/studies/caveman-token-usage-benchmark">awesome-ai-coding-assistants-playbook</a> repository, if you want to inspect the data or reproduce the tests.</p><blockquote>This study is part of a series of content about AI-assisted development that we’re exploring at <a href="https://www.youtube.com/@CodandoTV">CodandoTV</a><a href="https://www.youtube.com/@CodandoTV).*">.</a></blockquote><p>Any questions or feedback, find me on <a href="https://www.linkedin.com/in/rviannaoliveira/">LinkedIn</a> or on the <a href="https://www.youtube.com/@CodandoTV">CodandoTV</a> channels.*</p><p>If you’d rather watch than read, I recorded a video about this study on CodandoTV: <a href="https://youtu.be/T4Uiv4VwJpM?si=wyGdr6Dgm16GQND4">Watch on YouTube</a></p><p>That’s all folks!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=469c8047c75d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/does-caveman-actually-save-tokens-i-built-a-benchmark-to-find-out-469c8047c75d">Does Caveman Actually Save Tokens? I Built a Benchmark to Find Out</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desmistificando o SDD com agentes de IA: entenda o conceito antes dos comandos]]></title>
            <link>https://medium.com/codandotv/desmistificando-o-sdd-com-agentes-de-ia-entenda-o-conceito-antes-dos-comandos-ce6d519b460a?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce6d519b460a</guid>
            <category><![CDATA[spec-driven-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Mon, 27 Apr 2026 02:24:02 GMT</pubDate>
            <atom:updated>2026-08-02T16:16:16.217Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZGj1PiUdko4s3G1hVOoD3g.png" /></figure><p>Você começa a estudar SDD(Spec Driven Development) e acontece isso:</p><blockquote>`requirements.md`, `proposal.md`, `spec.md`.</blockquote><p>Três nomes diferentes. Mesma etapa.</p><p>Quando comecei a estudar SDD, esse tipo de coisa me travava. Cada ferramenta usava sua própria terminologia, e eu ficava tentando decorar os nomes em vez de entender o que cada etapa representava. Resultado: quando via alguém usando uma ferramenta diferente da que eu tinha estudado, parecia que estava aprendendo tudo do zero.</p><p>Aí vem o planejamento. Kiro e OpenSpec chamam de <strong>design.md</strong>. Spec Kit chama de <strong>plan.md</strong>. Claude Code, Copilot e Gemini não geram arquivo nenhum, entram num modo read-only e apresentam o plano pra você aprovar. Mesmo conceito, formas completamente diferentes de chegar lá.</p><p>E na hora de executar: <strong>/opsx:apply</strong> no OpenSpec, <strong>/speckit.implement</strong> no Spec Kit, <strong>Agent mode</strong> no Copilot.</p><p>Mesmo processo. Vocabulários completamente diferentes.</p><p>Foi aí que parei de tentar decorar e fui atrás dos conceitos. E quando o conceito ficou claro, qualquer ferramenta passou a fazer sentido.</p><p>A ideia deste artigo é exatamente essa: modelo mental antes dos comandos. Vou usar o contexto Mobile, que é onde eu vivo, mas os conceitos se aplicam a qualquer stack.</p><h4>O problema de aprender pelo framework e não pelo conceito</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*jsMF75XNIxa3HzqIG2al5g.png" /></figure><p>Imagina que alguém quer te ensinar injeção de dependência. Em vez de explicar o conceito (inverter o controle das dependências para tornar o código testável e desacoplado), eles abrem direto no Hilt ou Koin e começam a mostrar como usar um <strong>@HiltAndroidApp, @Inject, @Module ou factory, module, qualifier.</strong></p><p>Você aprende a usar o Hilt, mas se amanhã o projeto migrar pro Koin, você está de volta ao zero. Afinal, ambos resolvem o mesmo problema de jeitos bem diferentes: um é focado em estrutura de árvore, o outro em service locator. O conceito nunca foi explicado.</p><p>Com SDD acontece exatamente isso. A maioria dos conteúdos ensina OpenSpec, ou Spec Kit, ou Kiro, e pula o conceito. Daí quando você troca de ferramenta, ou vê alguém usando outra, parece que está aprendendo tudo do zero, e até as configurações que foram feitas não foram aproveitadas, pois essas ferramentas geram <strong>.mds</strong> nas suas próprias estruturas.</p><h3>O que realmente é SDD</h3><p>Vou usar o <a href="https://github.com/CodandoTV/CraftD"><strong>CraftD</strong></a> como exemplo ao longo do artigo. É um framework open source de Server Driven UI mantido pela <a href="https://www.youtube.com/c/CodandoTV"><strong>CodandoTV</strong></a>, com suporte a Android, iOS, Flutter e KMP. Foi nele que apliquei o SDD com <strong>OpenSpec</strong>, tanto na criação da estrutura de componentes quanto na manutenção do projeto.</p><p>SDD é uma abordagem onde você<strong> tira a decisão da execução e coloca na especificação.</strong></p><p>Ou de forma mais prática:</p><blockquote>você para de “pensar enquanto coda”<br>e passa a “codar o que já foi pensado”.</blockquote><p>Em vez de abrir o chat do Claude e dizer “adiciona suporte a um novo componente no CraftD” você primeiro documenta o que precisa ser feito e por quê, planeja como vai fazer, quebra em tarefas atômicas e aí sim pede para o agente executar.</p><p>A diferença não é de ferramenta. É de onde a<strong> decisão acontece.</strong></p><p>Esse processo tem duas partes. A primeira é feita uma vez, quando você configura o projeto:</p><pre><strong>CONFIGURAÇÃO ( Arquivo de Inicialização do Modelo)</strong></pre><p>A segunda acontece a cada mudança. Você parte de uma ideia ou objetivo, se comunica com o modelo em linguagem natural (isso é a etapa de *exploração*) e então segue o fluxo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*cw59pGmH5qjM-RnZ5f041g.png" /></figure><p>O que muda entre as ferramentas é o nome e o arquivo que cada uma usa em cada etapa. Vamos destrinchar uma por uma.</p><blockquote>Vale lembrar: estou falando das ferramentas que usei ou estudei. Se você usa outra, o de/para pode ser diferente.</blockquote><h4>Antes das camadas: a exploração</h4><p>Antes de entrar no fluxo formal, algumas ferramentas oferecem um passo opcional de exploração. A ideia é simples: você ainda não sabe direito o que quer construir, quer pensar em voz alta, investigar o problema antes de formalizar qualquer coisa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/458/1*b1hePWTeG0glXb5kNDvynQ.png" /></figure><p>Esse passo não gera nenhum arquivo. É só um rascunho mental. Quando você sabe o que quer construir, vai direto para a especificação.</p><p>E aqui eu tive uma confusão também que pode te ajudar a esclarecer: o <strong>Plan Mode</strong> não é equivalente ao <strong>explore</strong>. São coisas de camadas diferentes</p><blockquote>O <strong>explore</strong> responde:<br>- o que eu quero construir?</blockquote><blockquote>O <strong>Plan Mode </strong>responde:<br>- como eu vou implementar isso tecnicamente?</blockquote><p>Parece sutil, mas é a diferença entre descobrir o problema e resolver o problema.</p><h3>Camada 1: Configuração (Arquivo de Inicialização)</h3><p><strong>O conceito: garantir que o agente conheça as regras do projeto antes de qualquer tarefa.</strong></p><p>Sem essa camada, toda vez que você pede algo pro agente, ele começa do zero. Não sabe a arquitetura, não sabe os padrões, não sabe o que pode e o que não pode. Você ou explica tudo no prompt toda vez, ou torce pra ele adivinhar certo.</p><p>Vale citar também as skills, que seguem a mesma lógica de não recomeçar do zero. A diferença é sutil: configuração é passiva, o agente carrega sempre sem você acionar. Skills são procedimentos que você aciona quando precisa. O que pouca gente sabe: o agente faz um mapeamento de todos os arquivos de skill lendo o <strong>name </strong>e <strong>description</strong> de cada um. Quando vem um contexto ou palavra-chave que bate com o que ele mapeou, ele decide se lê o arquivo inteiro ou não pra aquela tarefa. É assim que ele sabe qual skill é relevante sem você precisar dizer explicitamente. Por isso o modelo não garante que vai sempre executar as skills: se o <strong>name</strong> e <strong>description</strong> não estiverem bem mapeados, ele simplesmente não vai associar.</p><p>Arquivo de Inicialização resolve isso: você define as regras uma vez, e o agente as carrega em todas as tarefas automaticamente.</p><p><strong>Como os modelos implementam isso:</strong></p><p>No Claude Code, você cria um arquivo chamado <strong>CLAUDE.md</strong> na raiz do projeto. Ele é lido automaticamente no início de cada sessão. Não precisa referenciar, não precisa passar no prompt. O agente simplesmente carrega. Não é uma convenção SDD, é como o Claude Code funciona.</p><p>O Copilot faz a mesma coisa pelo <strong>.github/copilot-instructions.md</strong>, lido automaticamente via configuração do repositório.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/495/1*z_Dz0XVcEPoYhHRJCpBh4Q.png" /></figure><p><strong>Como o Spec Kit formaliza isso como etapa SDD:</strong></p><p>O Spec Kit vai além e transforma a configuração em um arquivo explícito do fluxo: o <strong>constitution.md</strong>. Em vez de deixar as regras implícitas, você cria esse arquivo como primeiro passo do processo, antes de especificar qualquer coisa. É uma ferramenta com uma opinião forte sobre como isso deve ser feito.</p><p>O conteúdo é o mesmo que você colocaria no <strong>CLAUDE.md</strong>: princípios de arquitetura, padrões, restrições. O que muda é que no Spec Kit isso vira um passo formal, não uma configuração de fundo.</p><h4><strong>No contexto do CraftD</strong> (Biblioteca de Server Driven UI do CodandoTV para Android, iOS, Flutter e KMP):</h4><ul><li>“Módulos de plataforma (android, ios, flutter) não podem depender uns dos outros, só do core”</li><li>“Todo novo componente deve implementar a abstração <strong>CraftDBuilder</strong>”</li><li>“O comportamento de fallback via <strong>onAction</strong> deve estar sempre coberto”</li></ul><p>Se é algo que o agente precisaria saber antes de qualquer tarefa, pertence à configuração.</p><h3>Camada 2: Especificação</h3><p><strong>O conceito: documenta o quê e o porquê antes de qualquer código.</strong></p><p>Antes de planejar como fazer, você precisa ter claro o que vai fazer e por que. Essa camada responde: qual o problema? quem é afetado? quais os critérios de sucesso? quais as restrições?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*7Z58JXgHVwVHCn-yFV7aSQ.png" /></figure><p>Claude Code, Copilot e Gemini não têm um arquivo de especificação próprio. Eles são os agentes que executam o processo, e você integra um framework como OpenSpec ou Spec Kit por cima.</p><h4><strong>No contexto do CraftD:</strong></h4><p>Sem essa camada, você abre o chat e fala “adiciona um componente de carrossel”. O agente cria algo. Mas em qual módulo? Com quais critérios de aceite? Integrando com o quê?</p><p>Com essa camada, você escreve: “precisamos de um componente de carrossel porque o time de produto quer permitir exibição de múltiplos banners via Server Driven UI sem nova versão do app. Módulos afetados: android, ios. Critério de sucesso: renderiza lista horizontal de itens recebida pelo JSON de resposta.”</p><p>O agente agora tem contexto suficiente para tomar decisões consistentes.</p><blockquote><strong>Uma dúvida que tive na prática</strong>: no começo do fluxo, fiquei na dúvida se deveria rodar um `/opsx:explore` antes de propor qualquer coisa. Afinal, o explore existe, por que não usar? A resposta que cheguei: o explore é um <strong>parceiro de pensamento</strong>, não uma etapa obrigatória. Ele serve pra quando você tem dúvidas sobre o que quer construir, quer pensar em voz alta antes de formalizar, ou está investigando um problema complexo. Se você já sabe o que quer, vai direto pro `/opsx:propose`. O `explore` é o rascunho mental, não o passo 1 do processo.</blockquote><h3>Camada 3: Planejamento</h3><p><strong>O conceito: documenta o como, ou seja, as decisões técnicas de implementação.</strong></p><p>Com o quê e o porquê definidos, essa camada responde: como vai ser feito? Quais abstrações usar? Quais módulos impactados? Qual a sequência lógica?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*alV8n8LZ3tBHRDwitVr0JQ.png" /></figure><p>O <strong>Plan Mode</strong> do Claude Code, Copilot e Gemini são os mais diferentes aqui: em vez de gerar um arquivo, entram num modo de análise read-only. Investigam a codebase, formulam um plano e apresentam para aprovação antes de qualquer mudança.</p><p>Útil para validar rapidamente. Mas sem um arquivo salvo, o plano não é rastreável e não alimenta automaticamente as etapas seguintes.</p><p>E pra deixar claro o ponto que mencionei antes: o <strong>Plan Mode</strong> fica nessa camada, não na pré-exploração. O `<strong>explore</strong>` do OpenSpec responde “o que quero construir?”. O <strong>Plan Mode</strong> responde “como vou construir isso tecnicamente?”. Parece sutil, mas a diferença de momento é grande: exploração acontece antes de qualquer arquivo, planejamento acontece depois que a especificação já está definida.</p><blockquote><strong>Uma dúvida que tive:</strong> uma vez me perguntei se o `/opsx:explore` servia só pra projetos que já têm código. Afinal, o explore investiga a codebase, certo? Errado. O explore funciona como parceiro de pensamento em qualquer contexto. Num repo do zero, ele te ajuda a pensar sobre estrutura, fluxo, decisões que você ainda não tomou. Investigar código é só uma das coisas que ele faz.</blockquote><h3>Camada 4: Quebrar em tarefas</h3><p><strong>O conceito: quebra o plano em tarefas independentes e executáveis.</strong></p><p>Essa é a camada mais consistente entre todas as ferramentas. Todas chamam de tasks, todas usam <strong>tasks.md</strong>, todas seguem o mesmo princípio: cada tarefa deve ser pequena o suficiente para ser executada e verificada de forma isolada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/383/1*i5EfGKUEqZMsvm5LDRCpXg.png" /></figure><blockquote><strong>Vale mencionar</strong>: tarefas independentes abrem espaço pra você entrar num universo de Multi Agents. Você pode ter inicialmente um agente planejador para analisar e distribuir as tarefas entre N agentes em paralelo, e outro agente responsável por revisar e documentar o resultado.</blockquote><h3>Camada 5: Execução</h3><p><strong>O conceito: o agente entra em cena como executor, com todo o contexto já estruturado nas camadas anteriores. Pensa nele como um colaborador seu: você repassou o contexto completamente, explicou o problema, o plano, as tarefas. Agora é só delegar e deixar executar.</strong></p><p>Essa é a camada onde existe uma chance alta de quebra o processo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*4R8ja_5_tSputYoxQPDglg.gif" /></figure><p>Você passou pelas camadas anteriores, criou os arquivos de cada etapa, tem o contexto todo estruturado, mas na hora H abre o chat e fala: “ó, implementa essa feature”. O processo estava certo, mas na execução voltou ao improviso.</p><p>E aí você perde exatamente o benefício do SDD.</p><p>Na prática isso vira:</p><ul><li>código inconsistente com o que foi planejado</li><li>decisões sendo refeitas durante a execução</li><li>dependência de prompt ao invés de processo</li></ul><p>Ou seja: você voltou pro ponto inicial sem perceber.</p><p>A execução dentro do SDD não é abrir um chat vazio. É acionar o agente apontando para o diretório que você construiu nas etapas anteriores.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/505/1*iqX4xgfOlfy5jGWVLT163A.png" /></figure><p><strong>O framework organiza o processo. O agente executa o processo.</strong></p><p>Exemplo:</p><p>O OpenSpec é o roteiro. O Claude é o ator que segue o roteiro. Quando você faz um<strong> `/opsx:apply`</strong>, está dizendo para o Claude: “leia os arquivos que preparamos e execute”. O Claude não é o orquestrador. Você é.</p><blockquote><strong>Vale mencionar</strong>: o `/opsx:archive` do OpenSpec não é só mover a change pra um diretório de concluídas. Ele mescla as specs da change com as specs já existentes no projeto. Na prática pode não fazer diferença no dia a dia, mas fica a seu critério avaliar se é útil pra documentação do projeto, isso significa que no próximo `/opsx:propose`, o agente já tem contexto do que foi feito antes: impactos, decisões, mudanças. O histórico vira insumo pra próxima especificação.</blockquote><blockquote><strong>Uma dúvida que tive na prática</strong>: quando fui usar o OpenSpec pela primeira vez, tentei rodar `/opsx:apply` direto no terminal. Erro. Fiquei um tempo tentando entender o que estava errado, até perceber que os slash commands funcionam dentro da IDE, seja como prompt no Copilot ou como commands no Claude. Se quiser acionar o OpenSpec direto via terminal, o comando é outro: `openspec-apply-change`. Cada ferramenta tem sua forma de chamar. Parece óbvio depois que você entende, mas ninguém deixa isso claro no começo.</blockquote><h3>O fluxo completo lado a lado</h3><p>Para fechar, o fluxo de cada ferramenta traduzido para os conceitos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aciQp0BfizD7Yp74bieBhA.png" /></figure><p>Quando você vê um conteúdo novo sobre qualquer uma dessas ferramentas, ou qualquer outra que ainda vai surgir, tenta mapear o que está sendo mostrado para uma dessas camadas. O nome vai ser diferente. O conceito vai ser o mesmo.</p><h3><strong>Conclusão</strong></h3><p>O erro que eu cometi, e acredito que muitos cometem, foi tentar aprender SDD decorando os comandos e os nomes dos arquivos para absorver logo na ‘prática’ antes de entender por que cada camada existe.</p><p>Configuração (arquivo de inicialização), especificação, planejamento, quebra de tarefas e execução são conceitos independentes de ferramenta. É a mesma confusão de quem aprende Koin sem entender injeção de dependência, funciona até o dia que precisa trocar de framework.</p><p>Com o modelo mental claro, você consegue pegar qualquer ferramenta (OpenSpec, Spec Kit, Kiro, o que vier) e mapear para as camadas. O nome vai ser diferente. O conceito vai ser o mesmo.</p><p>Se você está começando agora, tenta responder essas perguntas antes de criar qualquer arquivo:</p><ul><li>O que meu agente precisa saber <strong>sempre</strong>? Camada de configuração.</li><li>O que e por que vou construir? Camada de especificação.</li><li>Como vou construir? Camada de planejamento.</li><li>Quais são as tarefas atômicas? Camada de quebrar em tarefas.</li><li>Como vou acionar o agente com todo esse contexto? Camada de execução.</li></ul><p>Se você souber responder isso, você não depende mais da ferramenta.</p><p>Você só escolhe qual usar.</p><p><strong>Esse artigo faz parte de uma série sobre desenvolvimento com agentes de IA que estamos fazendo no CodandoTV.</strong></p><p>Tudo isso foi aplicado no <a href="https://github.com/CodandoTV/CraftD">CraftD</a> usando Claude+OpenSpec, junto com outros conceitos como `Single Source of Truth`, e em breve outros repositórios do CodandoTV também vão explorar outras ferramentas.</p><p>Qualquer dúvida ou sugestão, me encontra no <a href="https://www.linkedin.com/in/rviannaoliveira/">LinkedIn</a> ou no meu canal do youtube <a href="https://www.youtube.com/@CodandoTV">CodandoTV</a><a href="https://www.youtube.com/@CodandoTV).*">.</a></p><p>E ainda tem muito mais pra explorar. O SDD que vimos aqui é uma peça. Mas tem skills, MCP, orquestração com Multi Agents, e como tudo isso se conecta num conceito maior chamado <strong>harness</strong>: a infraestrutura completa que você monta ao redor do agente pra ele operar bem no seu projeto. Não é só contexto. É contexto + ferramentas + capacidade de agir.</p><p>Mas vamos começar acendendo uma vela antes de soltar uma bola de fogo!🔥🔥🔥</p><p>Isso é tudo Pessoal!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce6d519b460a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/desmistificando-o-sdd-com-agentes-de-ia-entenda-o-conceito-antes-dos-comandos-ce6d519b460a">Desmistificando o SDD com agentes de IA: entenda o conceito antes dos comandos</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CraftD: Server Driven UI for all platforms]]></title>
            <link>https://medium.com/codandotv/craftd-server-driven-ui-for-all-platforms-b2624d2c2a7b?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2624d2c2a7b</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[server-driven-ui]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Mon, 29 Jul 2024 17:45:54 GMT</pubDate>
            <atom:updated>2024-08-22T11:51:38.891Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*0RtQRd88MQP70K5XvDXLDg.jpeg" /></figure><p>Have you ever thought about creating app screens using the Server Driven UI concept quickly and easily?</p><p>The purpose of this article is to explain the solution and help you assess if it meets your needs. Within the text, you will find hyperlinks to code guides and variations focused on implementing each platform.</p><h4>Introduction to Server Driven UI</h4><p>A brief context for those who are not familiar with SDUI.</p><p>Server Driven UI is an innovative approach to user interface design and development. Instead of leaving the responsibility of building and managing the interface to the user’s device — which is quite common — SDUI delegates this task to the server. With the logic and data controlled server-side, the server decides how the interface should appear and behave. This allows for greater flexibility and the ability to quickly adapt the interface as needs change.</p><p>Due to these advantages, SDUI has gained prominence in recent years as an efficient solution for businesses that need to deliver interfaces quickly and in a customized way. Many companies are looking or developing their own solutions to implement this approach and adapt it to their specific scenarios. After all, who doesn’t want to make fast and effective deliveries?</p><p>When products are delivered quickly and with quality, all stakeholders are satisfied. And when everyone is happy, success is guaranteed, right?</p><h4>Meet CraftD!</h4><p>Now that I’ve introduced it, let’s go?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*Bq5BxNCsYMFSc3IyUBtbRA.gif" /></figure><h4>Origin and Evolution for All Platforms</h4><p>Due to this need, the CraftD library was born. It evolved from a previous solution called <a href="https://medium.com/codandotv/server-driven-ui-com-android-dynamic-views-o-guerreiro-mestre-de-armas-ee1d6527e471">DynamicView</a> (deprecated), which had been improved over the years. Some companies adopted this library or adapted it for their own needs.</p><p>However, I always felt the lack of a cohesive and uniform solution for all platforms. I wanted something that could be used not only on Android but also ensured a consistent and efficient experience during development, with consistent class names, methods, and practices for all platforms. Moreover, it needed to be versatile enough to be used in any project.</p><p>With this goal in mind, I started developing CraftD, and together with the <a href="https://medium.com/codandotv">CodandoTV</a> community, we created libraries for the development of dynamic interfaces using SDUI, supporting:</p><p>- Android Compose</p><p>- Android View System</p><p>- iOS SwiftUI</p><p>- <a href="https://medium.com/codandotv/craftd-an-ideal-solution-for-server-driven-ui-in-flutter-apps-fd777c3dd010">Flutter</a></p><p>- KMP Compose (in progress)</p><p>CraftD has the capability to support you in creating and customizing your own components, working with routes, sending analytics/monitoring, and is capable of receiving other streams smoothly while interacting with screen components and still supports you using your <strong>Design System</strong> and finally, most <strong>importantly</strong>, making deliveries without needing to upload a new app version in the store.</p><h4>Understanding the Solution</h4><p>The basis of the solution is to use native list components such as ListView (Flutter), RecycleView (ViewSystem), LazyColumn (Compose), LazyVStack (iOS) respective of their platforms. And using CraftD, you have an itemType mechanism ensuring all the responsibility for displaying the screen components.</p><p>With this, a sea of possibilities that CraftD delivers for you opens up, such as:</p><ul><li>The library is available on all common dependency managers:<strong> </strong><a href="https://codandotv.gitbook.io/craftd/setup/android"><strong>Android_KMP -&gt; Maven</strong></a><strong>, </strong><a href="https://codandotv.gitbook.io/craftd/setup/ios"><strong>iOS -&gt; Podfile</strong></a><strong> , </strong><a href="https://codandotv.gitbook.io/craftd/setup/flutter"><strong>Flutter -&gt; pub.dev</strong></a><strong>;</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*InC70m-x7QSaxfsQg-Qu5A.png" /><figcaption>Oficial Documentation from CraftD — Android Setup</figcaption></figure><ul><li>Easy implementation through the library, and in 5 steps, you can use <a href="https://codandotv.gitbook.io/craftd/how-to-use/android/compose#id-1.-create-your-componentpropertyclass-with-properties-that-you-need"><strong>Android_KMP</strong></a><strong>, </strong><a href="https://codandotv.gitbook.io/craftd/how-to-use/ios"><strong>iOS</strong></a><strong>, </strong><a href="https://codandotv.gitbook.io/craftd/how-to-use/flutter"><strong>Flutter</strong></a><strong>;</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kyAJ5hGQfCONO_CzxPCzwQ.png" /><figcaption>Oficial Documentation from CraftD — How to Use</figcaption></figure><ul><li>Use components from <strong>CraftD</strong>, that is, each platform within the lib <strong>already provides</strong> some <strong>components</strong> ready for you to use</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*dgAm7poy2ZSMrb9nbbmFDQ.png" /><figcaption>But it does not just stick to these, what the lib provides whether for you to consume or use as an example</figcaption></figure><ul><li><a href="https://codandotv.gitbook.io/craftd"><strong>Creation of customized components</strong></a> for your application and customization, within CraftD there is an abstraction called <a href="https://codandotv.gitbook.io/craftd/how-to-use/android/compose"><strong><em>CraftDBuilder</em></strong></a> which allows you to create any type of <strong>component</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o_BZBbUZVoAXhgYKK2_FdA.png" /><figcaption>Oficial Documentation from CraftD — Flutter How to use</figcaption></figure><ul><li>The flexibility to perform interactions with external actions, such as <strong>deeplink, sending metrics or monitoring</strong>, is guaranteed by the component called <strong><em>CraftDynamic</em></strong>. This component is responsible for the entire functioning of the library and is present in all its variants. Thus, all variants have a type of fallback that allows interaction with the user’s click actions.</li></ul><pre>//Exemplo Android<br>@Composable<br>fun InitialScreen(<br>    vm: SampleCraftDComposeViewModel<br>) {<br>    val properties by vm.properties.collectAsStateWithLifecycle()<br>    val craftdBuilderManager = remember {<br>        CraftDBuilderManager().add(<br>            MySampleButtonComposeBuilder()<br>        )<br>    }<br>    LaunchedEffect(Unit) {<br>        vm.loadProperties()<br>    }</pre><pre>    CraftDynamic(<br>        properties = properties,<br>        craftDBuilderManager = craftdBuilderManager<br>    ) {<br>       //Fallback<br>        println(<br>            &quot;&gt;&gt;&gt;&gt; category ${it.analytics?.category} -&quot; + &quot; action ${it.analytics?.action} -&quot; + &quot; label  ${it.analytics?.label} -&quot; + &quot; deeplink ${it.deeplink}&quot;<br>        )<br>    }<br>}</pre><ul><li>But if you still read and want to have the <strong>power</strong> to control the assembly of how it will be done on the screen and use just the <em>itemType</em> mechanism, you can also do this easily by creating your own variants of “<em>CraftDynamic</em>” and using the mechanism with the .craft method, remembering that this is standardized for all platforms.</li></ul><pre>//Exemplo Android<br>@Composable<br>fun MyComponent(<br>    properties: ImmutableList&lt;SimpleProperties&gt;,<br>    modifier: Modifier = Modifier,<br>    craftDBuilderManager : CraftDBuilderManager,<br>    onAction: (ActionProperties) -&gt; Unit<br>) {<br>    //LazyColumn or another component<br>    LazyColumn(<br>        modifier<br>    ) {<br>        items(<br>            count = properties.size,<br>          ) { index -&gt;<br>            val model = properties[index]<br>            val builder = craftDBuilderManager.getBuilder(model.key)<br>            <br>            // the craft method will take care of component management for you<br>            builder.craft(model = model) {<br>                onAction(it)<br>            }<br>        }<br>    }<br>}</pre><ul><li>Versatility to work with any <em>data source</em>, by default SDUI is data that comes from the server, that is, it can be used by any type of data source and in this example, it will use a JSON and an array of “components” and within it has two important fields, the key that will be used in the <em>itemType</em> to be able to distinguish what each component is and the value that can be anything that has been mapped in your object, yes anything at all! for example:</li></ul><pre>[<br>  {<br>    &quot;key&quot;: &quot;CraftDTextView&quot;,<br>    &quot;value&quot;: {<br>      &quot;text&quot;: &quot;Knife&quot;,<br>      &quot;backgroundHex&quot;: &quot;#9A71F6&quot;,<br>      &quot;textSize&quot;: &quot;30&quot;,<br>      &quot;textColorHex&quot;: &quot;#000000&quot;<br>    }<br>  },<br>  {<br>    &quot;key&quot;: &quot;CraftDButton&quot;,<br>    &quot;value&quot;: {<br>      &quot;text&quot;: &quot;Some Action :)&quot;,<br>      &quot;textColorHex&quot;: &quot;#9100a0&quot;,<br>      &quot;actionProperties&quot;: {<br>        &quot;deeplink&quot;: &quot;dynamicview://any&quot;,<br>        &quot;analytics&quot;: {<br>          &quot;category&quot;: &quot;hello&quot;,<br>          &quot;action&quot;: &quot;world&quot;,<br>          &quot;label&quot;: &quot;everywhere&quot;<br>        }<br>      }<br>    }<br>]</pre><p>Remembering that the example was given with a JSON coming from any API, however, it is worth reinforcing that it is necessary to have only a data source, that is, it can be from <em>RemoteConfig</em> or even locally or local json, etc..</p><p>With this, you would have all the flexibility of using <strong>CraftD</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*YGt1tN9BGEoFx_rbxyH00Q.gif" /></figure><p>I tried to offer an overview of the library for you. Follow the <a href="https://www.youtube.com/c/codandotv">CodandoTV</a> channel and the repository to stay updated. If you want to participate in this project, feel free to visit the repository or get in touch with me or talk with us in our <a href="https://discord.gg/h2r4VxG4">Discord</a> community.</p><p>If you want to follow the development, take a look our examples:</p><ul><li><a href="https://github.com/CodandoTV/CraftD/tree/main/android_kmp/app-sample">Android</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*Gcje8PLKsRWK5_BcoDIjAA.gif" /></figure><ul><li><a href="https://github.com/CodandoTV/CraftD/tree/main/ios/sample">iOS</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*6xaKLZfeyGgFyDuKz72_dw.gif" /></figure><ul><li><a href="https://github.com/CodandoTV/CraftD/tree/main/flutter/sample">Flutter</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*OvqCRyYxShI6Hs-UZpBHYQ.gif" /></figure><p>And that’s all folks. It is worth reinforcing that the idea of <strong>CraftD</strong> is not to be a silver bullet for all functionalities and screens, but for certain cases it will definitely meet your needs. Due to the levels of use that you can make, you will be able to adapt it to your project easily, as the idea of <strong>CraftD</strong> is to take responsibility for assembling your layout, leaving room to search from any data source, customizing your needs with your needs.</p><p>All documentation is on the website: <a href="https://codandotv.gitbook.io/craftd">https://codandotv.gitbook.io/craftd</a></p><p>Code repository: <a href="https://github.com/CodandoTV/CraftD">https://github.com/CodandoTV/CraftD</a></p><p>video: <a href="https://youtu.be/Co-e1QPD73M?si=pFCPfcirjZ7egHd7">https://youtu.be/Co-e1QPD73M?si=pFCPfcirjZ7egHd7</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2624d2c2a7b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/craftd-server-driven-ui-for-all-platforms-b2624d2c2a7b">CraftD: Server Driven UI for all platforms</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CraftD: Server Driven UI para todas as plataformas]]></title>
            <link>https://medium.com/codandotv/craftd-server-driven-ui-para-todas-as-plataformas-bb3de2653b78?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb3de2653b78</guid>
            <category><![CDATA[kmp]]></category>
            <category><![CDATA[server-driven-ui]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Mon, 29 Jul 2024 15:32:07 GMT</pubDate>
            <atom:updated>2026-08-04T15:06:37.280Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*0RtQRd88MQP70K5XvDXLDg.jpeg" /></figure><p>Você já pensou em criar telas de aplicativos utilizando o conceito Server Driven UI de maneira rápido e fácil?</p><blockquote>Abaixo segue a documentação traduzida que pode não estar atualizada no momento.</blockquote><blockquote>Para conferir a versão mais recente <a href="https://medium.com/@rodrigo.vianna.oliveira/craftd-server-driven-ui-for-all-platforms-b2624d2c2a7b">[acesse a página em inglês]</a></blockquote><p>A proposta deste artigo é explicar a solução e ajudar você a avaliar se ela atende às suas necessidades. Dentro do texto, você encontrará hyperlinks para guias de código e variações focadas na implementação de cada plataforma.</p><h4>Introdução ao Server Driven UI</h4><p>Dando um breve contexto para quem não sabe o que é SDUI.</p><p>A Server Driven UI é uma abordagem inovadora para o design e desenvolvimento de interfaces de usuário. Em vez de deixar a responsabilidade de construir e gerenciar a interface para o dispositivo do usuário que é bem comum, a SDUI delega essa tarefa ao servidor. Com a lógica e os dados controlados no lado do servidor, o servidor decide como a interface deve aparecer e se comportar. Isso permite uma maior flexibilidade e a capacidade de adaptar rapidamente a interface conforme as necessidades mudam.</p><p>Devido a essas vantagens, a SDUI tem ganhado destaque nos últimos anos como uma solução eficiente para empresas que precisam entregar interfaces rapidamente e de forma personalizada. Muitas empresas estão buscando ou desenvolvendo suas próprias soluções para implementar essa abordagem e adaptá-la aos seus cenários específicos. Afinal, quem não quer fazer entregas rápidas e eficazes?</p><p>Quando os produtos são entregues rapidamente e com qualidade, todos os stackeholders ficam satisfeitos. E quando todos estão felizes, o sucesso é garantido, não é mesmo?</p><h3>Conheça a CraftD!</h3><p>Agora que dei uma introdução, Bora?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*Bq5BxNCsYMFSc3IyUBtbRA.gif" /></figure><h4>Origem e Evolução para todas as plataformas</h4><p>Devido a essa necessidade, nasceu a biblioteca CraftD. Ela evoluiu a partir de uma solução anterior chamada <a href="https://medium.com/codandotv/server-driven-ui-com-android-dynamic-views-o-guerreiro-mestre-de-armas-ee1d6527e471">DynamicView</a>(depreciado), que já havia sido aprimorada ao longo dos anos. Algumas empresas adotaram essa biblioteca ou a adaptaram para suas próprias necessidades.</p><p>No entanto, eu sempre senti falta de uma solução coesa e uniforme para todas as plataformas. Queria algo que pudesse ser usado não apenas no Android, mas que também garantisse uma experiência uniforme e eficiente durante o desenvolvimento, com nomes de classes, métodos e, práticas consistentes. Além disso, precisava ser versátil o suficiente para ser usado em qualquer projeto.</p><p>Foi com esse objetivo em mente que iniciei o desenvolvimento do CraftD e em conjunto com a comunidade da <a href="https://medium.com/u/21357db423bc">CodandoTV</a>, criamos bibliotecas para o desenvolvimento de interfaces dinâmicas utilizando SDUI dando suporte para:</p><ul><li>Android Compose</li><li>Android View System</li><li>iOS SwiftUI</li><li>Flutter</li><li>KMP Compose ( em progresso)</li></ul><p>A CraftD tem a capacidade de dar suporte para você criar e customizar seus próprios componentes, trabalhar com rotas, enviar analytics/monitoramento e é capaz de receber outros fluxos de maneira fluída enquanto interage com os componentes de tela e ainda da suporte para você utilizar seu<strong> Design System </strong>e<strong> </strong>por fim o mais<strong> importante </strong>entregas sem precisar subir uma nova versão de aplicativo.</p><h4>Entendimento da solução</h4><p>A base da solução é utilizar componentes de listas nativas como: ListView(Flutter), RecycleView(ViewSystem), LazyColum(Compose), LazyVStack(iOS) respectivas de suas plataformas. E utilizando a CraftD você tem um mecanismo de <em>itemType </em>garantindo toda a responsabilidade de visualização dos componentes da tela.</p><p>Com isso, abre-se um mar de possibilidades que a CraftD entrega para você, como:</p><ul><li>A biblioteca está disponível em todos os gerenciadores de dependênicas mais comuns:<strong> </strong><a href="https://codandotv.gitbook.io/craftd/setup/android"><strong>Android_KMP -&gt; Maven</strong></a><strong>, </strong><a href="https://codandotv.gitbook.io/craftd/setup/ios"><strong>iOS -&gt; Podfile</strong></a><strong> , </strong><a href="https://codandotv.gitbook.io/craftd/setup/flutter"><strong>Flutter -&gt; pub.dev</strong></a><strong>;</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*InC70m-x7QSaxfsQg-Qu5A.png" /><figcaption>Documentação oficial da CraftD — Android Setup</figcaption></figure><ul><li>Implementação fácil pela biblioteca, e em 5 passos você consegue utilizar <a href="https://codandotv.gitbook.io/craftd/how-to-use/android/compose#id-1.-create-your-componentpropertyclass-with-properties-that-you-need"><strong>Android_KMP</strong></a><strong>, </strong><a href="https://codandotv.gitbook.io/craftd/how-to-use/ios"><strong>iOS</strong></a><strong>, </strong><a href="https://codandotv.gitbook.io/craftd/how-to-use/flutter"><strong>Flutter</strong></a><strong>;</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kyAJ5hGQfCONO_CzxPCzwQ.png" /><figcaption>Documentação oficial da CraftD — How to Use</figcaption></figure><ul><li>Utilizar componentes do <strong>CraftD</strong>, isto é, cada plataforma dentro da lib já <strong>fornece</strong> para vocês alguns <strong>componentes </strong>prontos para poder serem usados;</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*dgAm7poy2ZSMrb9nbbmFDQ.png" /><figcaption>Mas não se prende apenas a apenas esses, isso que a lib fornece seja para você consumir ou utilizar como exemplo.</figcaption></figure><ul><li><a href="https://codandotv.gitbook.io/craftd"><strong>Criação de componentes personalizados</strong></a><strong> </strong>para sua aplicação e customização, dentro da CraftD tem uma abstração chamada <a href="https://codandotv.gitbook.io/craftd/how-to-use/android/compose"><strong><em>CraftDBuilder</em></strong></a><em> </em>que possibilita que você possa criar qualquer tipo de <strong>componente</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o_BZBbUZVoAXhgYKK2_FdA.png" /><figcaption>Documentação oficial da CraftD — Flutter How to use</figcaption></figure><ul><li>A flexibilidade de realizar interações com ações externas, como <strong>deeplink, envio de métricas ou monitoramento</strong>, é garantida pelo componente chamado <strong><em>CraftDynamic</em></strong>. Esse componente é responsável por todo o funcionamento da biblioteca e está presente em todas as suas variantes. Dessa forma, todas as variantes possuem um tipo de fallback que permite interagir com as ações de clique do usuário.</li></ul><pre>//Exemplo Android<br>@Composable<br>fun InitialScreen(<br>    vm: SampleCraftDComposeViewModel<br>) {<br>    val properties by vm.properties.collectAsStateWithLifecycle()<br>    val craftdBuilderManager = remember {<br>        CraftDBuilderManager().add(<br>            MySampleButtonComposeBuilder()<br>        )<br>    }<br>    LaunchedEffect(Unit) {<br>        vm.loadProperties()<br>    }<br><br>    CraftDynamic(<br>        properties = properties,<br>        craftDBuilderManager = craftdBuilderManager<br>    ) {<br>       //Fallback<br>        println(<br>            &quot;&gt;&gt;&gt;&gt; category ${it.analytics?.category} -&quot; + &quot; action ${it.analytics?.action} -&quot; + &quot; label  ${it.analytics?.label} -&quot; + &quot; deeplink ${it.deeplink}&quot;<br>        )<br>    }<br>}</pre><ul><li>Mas se mesmo assim você leu e quer ter o poder de controlar a montagem de como vai ser feita na tela e utilizar apenas o mecanismo de <em>itemType</em>, você também consegue fazer isso facilmente criando suas próprias variantes de &quot;<em>CraftDynamic&quot;</em> e utilizando o mecanismo com o método<em> .craft, </em>lembrando que isso está padronizado para todas as plataformas.</li></ul><pre>//Exemplo Android<br>@Composable<br>fun MyComponent(<br>    properties: ImmutableList&lt;SimpleProperties&gt;,<br>    modifier: Modifier = Modifier,<br>    craftDBuilderManager : CraftDBuilderManager,<br>    onAction: (ActionProperties) -&gt; Unit<br>) {<br>    //LazyColumn or another component<br>    LazyColumn(<br>        modifier<br>    ) {<br>        items(<br>            count = properties.size,<br>          ) { index -&gt;<br>            val model = properties[index]<br>            val builder = craftDBuilderManager.getBuilder(model.key)<br>            <br>            // the craft method will take care of component management for you<br>            builder.craft(model = model) {<br>                onAction(it)<br>            }<br>        }<br>    }<br>}</pre><ul><li>Versatilidade de poder trabalhar com qualquer fonte de dados, por padrão o SDUI são dados que vêm do servidor, isto é, ele pode ser utilizado por qualquer tipo de fonte de dados e neste exemplo será utilizado um <em>Json</em> e um array de &quot;componentes&quot; e que dentro dele tem dois campos importantes, o key que será utilizado no <em>itemType </em>para conseguir distinguir o que é cada componente e o value que pode ser qualquer coisa que tenha sido mapeado no seu objeto, sim qualquer coisa mesmo! por exemplo:</li></ul><pre>[<br>  {<br>    &quot;key&quot;: &quot;CraftDTextView&quot;,<br>    &quot;value&quot;: {<br>      &quot;text&quot;: &quot;Knife&quot;,<br>      &quot;backgroundHex&quot;: &quot;#9A71F6&quot;,<br>      &quot;textSize&quot;: &quot;30&quot;,<br>      &quot;textColorHex&quot;: &quot;#000000&quot;<br>    }<br>  },<br>  {<br>    &quot;key&quot;: &quot;CraftDButton&quot;,<br>    &quot;value&quot;: {<br>      &quot;text&quot;: &quot;Some Action :)&quot;,<br>      &quot;textColorHex&quot;: &quot;#9100a0&quot;,<br>      &quot;actionProperties&quot;: {<br>        &quot;deeplink&quot;: &quot;dynamicview://any&quot;,<br>        &quot;analytics&quot;: {<br>          &quot;category&quot;: &quot;hello&quot;,<br>          &quot;action&quot;: &quot;world&quot;,<br>          &quot;label&quot;: &quot;everywhere&quot;<br>        }<br>      }<br>    }<br>]</pre><p>Lembrando que o exemplo foi dado com um JSON vindo de uma API qualquer, porém vale reforçar que é necessário apenas ter uma fonte de dados, isto é, podendo ser do <em>RemoteConfig</em> ou até localmente ou json local, etc..</p><p>Com isso você teria toda a flexibilidade da utilização do <strong>CraftD</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*YGt1tN9BGEoFx_rbxyH00Q.gif" /></figure><p>Tentei oferecer um resumo da biblioteca para vocês. Acompanhe o canal <a href="https://www.youtube.com/c/codandotv">CodandoTV</a> e o repositório para ficar por dentro das novidades. Se você quiser participar deste projeto, sinta-se à vontade para visitar o repositório ou entrar em contato comigo.</p><p>Caso queira acompanhar o desenvolvimento, siga o canal do youtube e fale com a gente na nossa comunidade do <a href="https://discord.gg/h2r4VxG4">Discord</a> confira nossos exemplos:</p><ul><li><a href="https://github.com/CodandoTV/CraftD/tree/main/android_kmp/app-sample">Android</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*Gcje8PLKsRWK5_BcoDIjAA.gif" /></figure><ul><li><a href="https://github.com/CodandoTV/CraftD/tree/main/ios/sample">iOS</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*6xaKLZfeyGgFyDuKz72_dw.gif" /></figure><ul><li><a href="https://github.com/CodandoTV/CraftD/tree/main/flutter/sample">Flutter</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*OvqCRyYxShI6Hs-UZpBHYQ.gif" /></figure><p>E isso é tudo galera. Vale reforçar que a ideia do <strong>CraftD</strong> não é ser uma bala de prata para todas as funcionalidades e telas, porém para determinados casos vai com certeza suprir suas necessidades. Devido aos níveis de utilização que você pode fazer, você conseguirá adaptar no seu projeto facilmente, pois a ideia do <strong>CraftD</strong> é assumir a responsabilidade de montar o seu layout, sobrando espaço para buscar de qualquer fonte de dados, customizando suas necessidades com as suas necessidades.</p><p>Toda a documentação está no site: <a href="https://codandotv.gitbook.io/craftd">https://codandotv.gitbook.io/craftd</a></p><p>Repositório do código: <a href="https://github.com/CodandoTV/CraftD">https://github.com/CodandoTV/CraftD</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb3de2653b78" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/craftd-server-driven-ui-para-todas-as-plataformas-bb3de2653b78">CraftD: Server Driven UI para todas as plataformas</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desmitificando a utilização de módulos de features dinâmicas-O Guia prático]]></title>
            <link>https://medium.com/codandotv/desmitificando-a-utiliza%C3%A7%C3%A3o-de-m%C3%B3dulos-de-features-din%C3%A2micas-o-guia-pr%C3%A1tico-50c86625a87?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/50c86625a87</guid>
            <category><![CDATA[dynamic-feature]]></category>
            <category><![CDATA[android-compose]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Thu, 20 Jun 2024 15:22:33 GMT</pubDate>
            <atom:updated>2024-06-20T15:23:08.812Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/708/1*R4ZYlxVDl_2JSQ6RHeGZdA.png" /><figcaption><a href="https://www.youtube.com/watch?v=httqEshs_Bk">https://www.youtube.com/watch?v=httqEshs_Bk</a></figcaption></figure><p>Configurar Módulos Dinâmicos é um dos grandes objetivos de todo desenvolvedor Android, basicamente essa é aquela funcionalidade que o Google nos fornece e pensamos.</p><blockquote>&quot;Pooo Eu quero colocar no projeto&quot;</blockquote><p>E devido as expectativas das entregas com o time de produto e até um pouco de ser um assunto meio místico, as vezes nunca vemos uma oportunidade real para isso, ou quando começar a colocar em um projeto de grande escala passamos por dificuldades, pois dependendo do tamanho do projeto pode demorar para fazer essa configuração devido a algumas peculiaridades de como funciona e conflitos de bibliotecas.</p><p>Devido a isso a ideia desse artigo é trazer um pouco a minha experiência e explicar de maneira resumida o que é um <em>Dynamic Feature</em> usando um <em>Setup Wizard</em> até porque já existem ótimos artigos que eu mesmo usei como referência também ( vou deixar abaixo nas referências), porém o foco principal será desmistificar o assunto dando algumas dicas, como utilizar de maneira genérica em um projeto real e o mais importante como testar de maneira eficiente.</p><p>Para dar um contexto para irmos logo para a prática vou explicar em um tweet sobre o<em> Dynamic Feature.</em></p><p>Basicamente ele se aproveita do uso do <a href="https://developer.android.com/guide/app-bundle"><strong>Android App Bundle</strong></a> que tem como finalidade criar vários pacotes de recursos do seu projeto e ao disponibilizar para o usuário ele apenas faz o download para o usuário o que da fato vai usar seja diferença de processadores / resolução de imagens, e ai que entra o<em> Dynamic Feature</em> que é mais um pacote que fica separado lá na google play esperando ser baixado.</p><p><strong>Setup Wizard</strong></p><p>Antes de começar a mostrar a estrutura que criei para se utilizar um <em>Dynamic Feature</em>, eu vou mostrar uma forma muito fácil de fazer um <em>sample</em> junto com você, para que você ganhe mais confiança e ajude a desmitificar um pouco esse assunto.</p><p>Dentro do proprio Android Studio, vai na opção New module lá vai ter um template de <em>Dynamic Feature</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*oz-r9dAZbxxNx1i4kM5CIw.png" /></figure><p>Adicione um titulo, no entanto é apenas visível para o usuário não sendo utilizado no desenvolvimento, e aproveita e inclui a opção Fusing , caso você deseja que seu módulo esteja disponível para dispositivos com Android 4.4 (API de nível 20) e inferior e incluído no multi-APK</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*_DtfNao_4UsFD0T79GOhAw.png" /></figure><p>Após isso, vamos entender o que o Android Studio criou de graça para você.</p><ol><li>Adicionou no settings.gradle seu modulo dinâmico para poder copilar</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/323/1*r6ZbaHb7a7CUBnP2Kptn7w.png" /><figcaption>settings.gradle</figcaption></figure><p>2. Associou no build.gradle do app o seu Dynamic Feature, aproveita e adiciona a lib da linha 16 que será utilizado mais para frente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/24b0cf8a44571d615e082e9e08cb23cb/href">https://medium.com/media/24b0cf8a44571d615e082e9e08cb23cb/href</a></iframe><p>3. E criou o modulo Dynamic Feature</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/553/1*b1PRIeuZnYdK3OXvgA0woA.png" /></figure><p>E aqui já vai a primeira dica, caso tenha reparado eu coloquei um <em>underscore</em> no nome do meu modulo, e isso é necessário se você quiser fazer um modulo com nome composto e não quiser deixar tudo junto, pois o -(traço/dash) da um problema na hora de você copilar seu dynamic feature com o projeto.</p><pre>The following feature module names contain invalid characters. Feature module names can only contain letters, digits and underscores.</pre><p>4. Dentro desse modulo criou nosso AndroidManifest com algumas peculiaridades:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e7c7864c56252fabeb08614c2f078554/href">https://medium.com/media/e7c7864c56252fabeb08614c2f078554/href</a></iframe><p>Foi adicionado um monte de coisa de graça pra gente, agora precisamos ainda configurar algumas coisas.</p><p>Dentro do build.gradle deste modulo adicione a lib do appCompat e a feautre-deliveryque é uma das libs da Google Play Core para criarmos nossa Activity.</p><p><a href="https://developer.android.com/guide/playcore">Overview of the Google Play Core libraries | Android Developers</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/19d73d1c2f63445c9a6232cd336c2125/href">https://medium.com/media/19d73d1c2f63445c9a6232cd336c2125/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/55b821e708f16f62715cb74a76660676/href">https://medium.com/media/55b821e708f16f62715cb74a76660676/href</a></iframe><p>E adicione o SplitCompat.installActivity(this) ele é super importante na hora quando você baixar seu modulo ele estar &quot;pronto&quot; para executar e achar os resources, ou você pode no seu applicationherdar por um SplitCompatApplication ou colocar no AndroidManifest esse &quot;split&quot;, independente da maneira que você escolha adicione, caso contrário irá aparecer esse erro:</p><pre>java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example.dynamicfeatureexample/br.com.rviannaoliveira.dynamic_feature.MyTestDynamicFeature}: android.content.res.Resources$NotFoundException: Resource ID #0x7e010000</pre><p>E caso já tenha reparado o dynamic_feature associado no modulo app com a opção do dynamic_feature, mas não nas dependências, e no modulo do dynamic_feature você está vendo ele dependendo do modulo app.</p><blockquote>Sim! parece confuso, mas vai ser bem pertinente na hora de você pensar como buildar em projetos reais!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*ShhqEIiPJ_5bUycJyO3-wQ.png" /></figure><p>Uma dica que vou dar agora é qualquer modulo criado como <em>Dynamic Feature</em> ele obedece as suas dependências e não é ele que dita as regras de como será sua configuração.</p><p>Nem tudo é feito tão automaticamente você ainda vai precisar configurar sua <em>Activity</em> do modulo app para chamar seu <em>Dynamic Feature, </em>mas não se preocupe o objetivo desse artigo é fazer você fazer primeiro funcionar para você entender a mecânica.</p><p>PS: o xml tem apenas um botão e um texto, então vou desconsiderar de colocar aqui.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/159614bc00874a74047a5d19894e30d0/href">https://medium.com/media/159614bc00874a74047a5d19894e30d0/href</a></iframe><p>Apenas copie por agora e da o Run ou se quiser utilizar o repositorio todo o código estará <a href="https://github.com/rviannaoliveira/VPlayground/tree/master/DynamicFeatureExample">aqui</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*vOVxdUm5iNsX5P1uBfjwog.gif" /></figure><blockquote>Conseguiu rodar?</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*-1XGV-3p4Yrti3DiOeWXjg.gif" /></figure><p>Porém nem tudo é o que parece, você pode ter executado e rodado, mas em tese você está apenas rodando o apk que já tem tudo dentro em tempo de compilação, mas não está fazendo o download da funcionalidade do modulo dynamic_feature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*Sxf6bZVq8B4-hmgG7DjUwA.png" /></figure><p>Para isso funcionar você tem que executar como se tivesse instalando um bundle.</p><p>Tem duas formas de fazer isso aonde, neste artigo explico com detalhes XXXXXXX como você pode testar seu <em>Dynamic Feature</em>, porém recomendo fortemente você ir para o caminho do <a href="https://developer.android.com/studio/command-line/bundletool?hl=pt-br#:~:text=bundletool%20%C3%A9%20a%20ferramenta%20que,s%C3%A3o%20criados%20com%20a%20bundletool%20."><strong>BundleTool</strong>.</a></p><blockquote>bundletool é a ferramenta que o Android Studio, o Plug-in do Android para Gradle e o Google Play usam para criar um Android App Bundle. bundletool pode converter um pacote de app para vários APKs que serão implantados em dispositivos.</blockquote><p>de maneira breve, você precisa instalar ele, no meu caso eu fiz pelo brew , então <a href="https://formulae.brew.sh/formula/bundletool">clique aqui </a>para fazer essa configuração.</p><p>após isso você executa esse comando que basicamente é rodar o bundle + pegar o arquivo aab e transformar em uma &quot;splits de apk&quot; para poder ser instalado dentro do seu próprio dispositivo simulando o que seria com a loja.</p><pre>./gradlew clean bundleDebug &amp;&amp; bundletool build-apks --overwrite --local-testing --bundle  ${PATH_REPO}/app/build/outputs/bundle/debug/app-debug.aab  --output ${PATH_REPO}/apkset.apks &amp;&amp; bundletool install-apks --apks ${PATH_REPO}/apkset.apks</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*JASiE4dLFch7YP_lQscwHA.gif" /><figcaption>300x650</figcaption></figure><p>Agora sim! Estamos fazendo nosso <em>Dynamic Feature</em> funcionar mesmo!!!</p><p>E para esse artigo é isso! A ideia era tentar te dar mais segurança para usar, e no próximo artigo iremos subir de nível e deixar de uma maneira genérica para poder usar em um modulo separado para poder baixar qualquer modulo pesando em projeto de grande escala, ficou interessado? Nos vemos la! _o/</p><p>Referências:</p><p><a href="https://developer.android.com/guide/app-bundle/dynamic-delivery"><em>About Dynamic Delivery</em></a></p><p><a href="https://codelabs.developers.google.com/codelabs/on-demand-dynamic-delivery/index.html?index=..%2F..index#0"><em>On Demand Modules Codelab</em></a></p><p><a href="https://developer.android.com/guide/playcore/feature-delivery/on-demand">Configure on demand deliver</a>y</p><p><a href="https://medium.com/android-dev-br/utilizando-m%C3%B3dulos-din%C3%A2micos-no-seu-app-android-e04875765586">Utilizando Módulos Dinâmicos no seu app Androi</a>d</p><p><a href="https://medium.com/android-news/app-bundles-and-dynamic-feature-modules-a-silver-bullet-for-bloated-apks-d0bcac151ae6">App Bundles and Dynamic feature module</a>s</p><p><a href="https://developer.android.com/guide/app-bundle/ux-guidelines"><em>UX best practices for on demand delivery</em></a></p><p><a href="https://issuetracker.google.com/issues/257765153">me ajudou com algumas problemas de &quot;Didnt find clas</a>s&quot;</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50c86625a87" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/desmitificando-a-utiliza%C3%A7%C3%A3o-de-m%C3%B3dulos-de-features-din%C3%A2micas-o-guia-pr%C3%A1tico-50c86625a87">Desmitificando a utilização de módulos de features dinâmicas-O Guia prático</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Perfect D&D Party for your Android Application]]></title>
            <link>https://medium.com/codandotv/the-perfect-d-d-party-for-your-android-application-8b5919661605?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b5919661605</guid>
            <category><![CDATA[dungeons-and-dragons]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[server-driven-ui]]></category>
            <category><![CDATA[analytics]]></category>
            <category><![CDATA[deeplink]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Mon, 03 Apr 2023 11:33:33 GMT</pubDate>
            <atom:updated>2024-06-20T15:26:17.983Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/515/1*HAJ53oeuDpm_yQptVtilLA.jpeg" /><figcaption><a href="https://www.rpgtavernadeferro.com/o-que-e-rpg-de-mesa/">https://www.rpgtavernadeferro.com/o-que-e-rpg-de-mesa/</a></figcaption></figure><p>This article is English version from the <a href="https://medium.com/@rodrigo.vianna.oliveira/d-d-party-perfeita-para-sua-aplica%C3%A7%C3%A3o-android-6fa4b94d8618"><strong>The Perfect D&amp;D Party for your Application</strong></a>( Portuguese Version)<strong>.</strong></p><p>At the present time, when we are working on a software project, we know that the development of all things Mobile has been featuring increasingly demanding and fast deadlines. Keeping that in mind, I am going to introduce to you a case in which the product team wanted to create campaigns to improve engagement and show offers of plans in the app, therefore resulting in a global solution for different project situations and functions. Let’s go!</p><p>The development team thought that, for the initial solution of the campaign, they should use some pre-specified templates in the project. The information available would be delivered under a determined API pattern to populate the screen data and basically show some types of layouts to the final user.</p><p>However, this solution had limited views and there was no progress to be seeing. Since I’m experienced with projects using the Server Driven UI concepts, I thought about a different idea, following another direction. Also, I wanted to put into practice a solution I had in mind and that was more refined for dynamic flows (I’ll go deeper into that soon), resulting in 4 major pillars for success.</p><p>Why can’t we make customized screens coming from the API with actions that may open other flows, with all of that being tracked? And, of course, using components standardized by the company (Design System)?</p><p>Starting from this point, I’m gonna show you not only a solution but a 4-pillar adventure (<a href="https://medium.com/@rodrigo.vianna.oliveira/server-driven-ui-com-android-dynamic-views-o-guerreiro-mestre-de-armas-ee1d6527e471">Server Driven Ui</a>, <a href="https://medium.com/@rodrigo.vianna.oliveira/roteamento-de-deeplink-com-deeplinkrouter-no-android-o-mago-implac%C3%A1vel-3f5d3ee22ed1">Navigation</a>, Analytics, and Design System, which were bundled together and won this quest).</p><p>Now, let’s go on an Adventure!</p><p>Previously, it was mentioned that the Product Castle Count had requested a mission, which was to help the castle peasants (users) to find new supplies of resources (functionalities) and treasures (plan offers), and make them experience a better life, living in a happier castle (application).</p><p>The Paladin was called out to try to solve this situation since the proposal made would not meet all the needs of the kingdom (company). This is a huge challenge, right? So, the Paladin decided to hire a group of adventurers to make this expedition.</p><p>But, before that, to complete this quest, I need your contribution to create a magic potion to help our noble adventurers! The truth is that one ingredient is missing for the potion, which is readers subscribing to my <a href="https://www.youtube.com/c/CodandoTV">YouTube channel</a>. After they subscribe, the potion will be complete and they will have more chances to achieve their mission goals with success.</p><h3>The Great Weapon Master (Server Driven UI)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*hkxLw6RE9UQzY_jmzAP17g.png" /><figcaption><a href="http://rpgmassacre.blogspot.com/2013/02/dicas-de-interpretacao-parte-3-guerreiro.html">http://rpgmassacre.blogspot.com/2013/02/dicas-de-interpretacao-parte-3-guerreiro.html</a></figcaption></figure><p>Based on the Server Driven UI concept, <a href="https://medium.com/@rodrigo.vianna.oliveira/server-driven-ui-com-android-dynamic-views-o-guerreiro-mestre-de-armas-ee1d6527e471"><strong>The Great Weapon Master</strong></a><strong> </strong>is a feat that presents all versatilities and the power of adaptation during the most adverse times, relying upon an endless range of weapons, therefore stating that, with his talents, he may be anything, anywhere. Also, since he is always on the front line, he will be protecting his allies (who can increase even more his power).</p><p>I have previously worked with and developed this solution. It basically means to use a RecyclerView with multiple types of items, in which each ViewType will be a component. To do this, we need to use as a basis a concept known as <a href="https://medium.com/android-news/simplifying-the-work-with-recyclerview-a64027bca8c3">ViewRender</a>, which is a way to simplify data entry to convert it into a legible type for our adapter that will be subsequently depicted on our screen. After that, I created version 2.0 of the solution, called Dynamic Views, which is responsible for the mechanism that dynamically shows any screen elements.</p><p>If you want to know more about the talents of this master, I wrote an article explaining how to use the <a href="https://medium.com/@rodrigo.vianna.oliveira/ee1d6527e471"><strong>Dynamic Views library.</strong></a></p><h3>The Undeterred Wizard (Navigation)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*VmTTRShkzKoNx1RAxvfqcQ.png" /><figcaption><a href="https://twitter.com/patopapao/status/971814332051935233?lang=es">https://twitter.com/patopapao/status/971814332051935233?lang=es</a></figcaption></figure><p><a href="https://medium.com/@rodrigo.vianna.oliveira/roteamento-de-deeplink-com-deeplinkrouter-no-android-o-mago-implac%C3%A1vel-3f5d3ee22ed1"><strong>The Undeterred Wizard,</strong></a> with all its magic, can transport its allies to different parts of the kingdom/dungeons/forest with a blink of an eye, making them arrive faster to their destination. He<strong> </strong>represents the fact that, in mobile projects, the navigation between screens is often required, whether through internal flows or from external links redirected to your application, which are known as <strong>Deep Link.</strong></p><p>The initial idea was to create a library to make the use of Deep Links easier in the project and there is a reason for that: when we are working with Android development, there is a specific issue, which is to access unrelated screens in a module project.</p><p>Also, the use of internal and external deep links in a large-scale project is a practice even more employed as a resource that enhances not only the project, but the product itself. Because of that, the solution is basically mapping the project’s front doors in 3 steps:</p><h4><strong>step 1:</strong></h4><ul><li>Register the application name, that is, the entry door for all registered routes (scheme);</li><li>Map all routes (authority);</li><li>Create objects for each functionality that has its own authority, path, and stack screen;</li></ul><h4>step 2:</h4><ul><li>Create your routes (DeeplinkRouteProcessor) according to the screens that will be shown, that is, each screen of your application will open an Activity;</li></ul><h4>step 3:</h4><ul><li>The library gathers all of this information and makes a search to the deep link passed through the authority, identifying this object and bringing the route created by DeeplinkRouteProcessor with its Activity and stack of Activities(if any), therefore creating Intents to open the screen with its entire stack.</li></ul><p>If you want to know more about its talents, I wrote an article explaining how to use the <a href="https://medium.com/@rodrigo.vianna.oliveira/3f5d3ee22ed1"><strong>DeeplinkRouter library.</strong></a></p><h3>The Hunter Ranger (Analytics)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*xWrWm7OFHbUxECS5iwUe3A.png" /><figcaption><a href="https://br.pinterest.com/pin/646125877762690161/">https://br.pinterest.com/pin/646125877762690161/</a></figcaption></figure><p>Known as <strong>The Information Hunter Ranger</strong>, her abilities involve tracing back and forward the paths she did pass through and the ones she will walk now and in the future; with this skill her party never gets lost. She uses mental connections to nature to understand the intentions of any animal (NewRelic, Analytics, and so on) and transmits all the information obtained to her allies.</p><p>This solution has also generated a library, that is a place in which the metrics libraries are centered (NewRelic, Analytics, and so on), and that works as a delegate, that is, it directs events to each specific library. In this case, the solution creates an abstraction for each external library, turning the classes predefined by type of monitoring into the entry point; after that, the metrics library the event is being directed to is then identified. It is not only a versatile solution, but it enables the use of several types of customizations in an organic way, that can be understood by the lib.</p><p>If you want to know more about her skills and fellow animals, you’re gonna have to wait a little bit since her article is still under training and will only be published after the Ranger passes to the next level.</p><h3>The Knowledge Domain Cleric (Design System)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/241/1*i7KTBHzDxWnVGWGcYKMJJQ.jpeg" /><figcaption><a href="https://br.pinterest.com/pin/3448137205973777/">https://br.pinterest.com/pin/3448137205973777/</a></figcaption></figure><p><strong>The Knowledge Domain Cleric</strong> uses her knowledge to guide her allies according to the doctrine (documentation) of the kingdom, raising up her sun symbol to use her transmutation magic and change the warrior’s weapons during the fight. Also, she evangelizes the entire kingdom with her religion, channeling her divinity and showing that they do not have to worry about working repeatedly in something that her god already provides.</p><p>She is based on the Design System, which is a unified system that employs standards and components established by the company. The Cleric has a collection of components that must be reusable for determined products, going way further instead of limiting to some components; she also creates the company’s visual identity and some benefits can be perceived through this action, such as:</p><ul><li>Optimization of the development time of the teams that are implementing screens;</li><li>Decreased duplicate project components;</li><li>Reuse of codes since the entire component structure is already done;</li></ul><p>However, to make things work correctly, it is necessary to create a collaborative culture in the company, in which everyone is involved in this process and helps create documents, new solutions, and new components.</p><h3>Party formation for this quest (Flow Chart):</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c6XDZ3kW39iJNmU-I4ZSKw.png" /></figure><h3>Results obtained with a sample:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/288/1*DPlrrmZIDqNYM_ce3EUjWQ.gif" /><figcaption>Example of DynamicView publishing a Toast with the Analytics events</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/288/1*yNwY_1FcMq3rduqI2dm_yA.gif" /><figcaption>Example of DeeplinkRouter</figcaption></figure><h3>Let’s celebrate at the Tavern!</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*vkHan8ZUzVAzOrPxgiJRGQ.jpeg" /><figcaption><a href="https://www.dungeonsolvers.com/2018/05/18/party-composition/">https://www.dungeonsolvers.com/2018/05/18/party-composition/</a></figcaption></figure><p>This solution is actually not limited to campaigns; it has been expanded to other types of functionalities that require the use of these 4 pillars, and I have observed great outcomes and increased speed for the teams when they use it.</p><p>That’s it, guys. With this article, I wanted to make an analogy that was a little different from what we usually see, and soon there will be other adventurers on new missions! Wait and see… You can tell me below what you think about this approach.</p><p>If you want to know more technically about the party members:</p><ul><li><a href="https://medium.com/@rodrigo.vianna.oliveira/server-driven-ui-com-android-dynamic-views-o-guerreiro-mestre-de-armas-ee1d6527e471">Server Driven UI com Android Dynamic Views - &quot;O Guerreiro Mestre de Armas&quot;</a></li><li><a href="https://medium.com/@rodrigo.vianna.oliveira/roteamento-de-deeplink-com-deeplinkrouter-no-android-o-mago-implac%C3%A1vel-3f5d3ee22ed1">Roteamento de Deeplink com DeeplinkRouter no Android - &quot;O Mago Implacável&quot;</a></li></ul><p>Ranger -&gt; in process;</p><p>Cleric -&gt; no technical references will be shown;</p><p>I welcome comments and suggestions. You can make them below or contact me through <a href="https://www.linkedin.com/in/rviannaoliveira/">LinkedIn</a> or <a href="https://flow.page/rviannaoliveira">https://flow.page/rviannaoliveira</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b5919661605" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/the-perfect-d-d-party-for-your-android-application-8b5919661605">The Perfect D&amp;D Party for your Android Application</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como estudar melhor uma tecnologia? "O que? Por que? Como? Quando?"]]></title>
            <link>https://medium.com/codandotv/como-estudar-melhor-uma-tecnologia-o-que-por-que-como-quando-332cfef36775?source=rss-8e062bd797cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/332cfef36775</guid>
            <category><![CDATA[tecnologia]]></category>
            <dc:creator><![CDATA[Rodrigo Vianna Calixto de Oliveira]]></dc:creator>
            <pubDate>Tue, 10 May 2022 12:18:45 GMT</pubDate>
            <atom:updated>2024-06-20T15:26:03.081Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l09plr2Wy3vj_e79crIQFQ.jpeg" /></figure><p>Quando converso com pessoas na nossa área para troca experiências sobre algum ponto ou até opinião sobre algum tema específico, um tema que acaba sempre levantado são as formas de estudo para ter aprendido aquele conteúdo e eu vou trazer o que eu faço para me aprofundar tecnicamente sobre alguma tecnologia. Com isso, trago neste artigo as 4 maneiras que utilizo para me aprofundar tecnicamente sobre alguma tecnologia.</p><p>Antes de tudo, quero deixar claro que não estou querendo falar que essa é a melhor forma para se estudar. É apenas mais uma ferramenta para a sua caixa de ferramentas, para você utilizar.</p><p>Eu procuro dividir em 4 partes separadas por cada objetivo e nível diferente.</p><h4>O que?</h4><p>Inicialmente quando estamos fazendo algo para entregar ou simplesmente estudando de maneira superficial para ficar antenado ou para saber a existência de algum assunto só para não ficar desatualizado, o primeiro ponto é saber &quot;<strong>o que&quot;</strong> é que você está mexendo, por exemplo:</p><p>Vou estudar uma nova tecnologia de Injeção de dependência, <strong>o que</strong> é ela/<strong>o que</strong> ela faz/<strong>o que</strong> ela precisa para usar/<strong>o que </strong>fazer com ela no projeto /<strong>o que</strong> eu preciso usar.</p><p>Isso ajuda a dimensionar sua necessidade, pode ter cenários em que você só precise ficar até aqui e saber o que fazer até porque não estou falando que é um problema você não se aprofundar nos temas, existe situações que você só precisar saber &quot;<strong>o que</strong>&quot; fazer e usar um ou dois ou até três métodos e esta tudo bem esse nível já é o suficiente.</p><h4>Por quê?</h4><p>Neste ponto, você começa a querer questionar o <strong>porquê</strong> de usar alguma tecnologia, entender se de fato ela vai suprir suas necessidades de uso. Verificar até muitas vezes <strong>porque</strong> as pessoas tem usado no mercado se tem algumas limitações, e todas as duvidas relacionadas a implementação dela no uso apenas. Sendo esse cenário digamos é aonde a maioria das pessoas costumam parar até porque também não viram ou não precisaram ir mais além disso.</p><h4>Como?</h4><p>Aqui começa a entrar num mundo sem volta onde você quer saber <strong>como</strong> funcionam as coisas e não apenas utilizar alguma biblioteca ou tecnologia e sim como aquilo foi feito até chegar no ponto de você usa-la. Eu comentei acima que é um caminho sem volta que dependendo da situação da tecnologia que você esta implementando ou estudando você começa a ver todas as classes do projeto, começa a ler a documentação implementada dentro de cada método, começa a querer fazer <em>playground</em> curtos com a finalidade de apenas fazer testes de cenários para explorar ainda mais o comportamento daquilo, devido a isso acabando ajudando a resolver possíveis bugs de maneira mais rápida, não que o estado de <strong>porque </strong>não te ajude a resolver bugs, porém existem bugs que você resolve e outros que você consegue entender <strong>porque</strong> aconteceu aquilo baseado no <strong>como</strong> funcionam para posteriormente corrigi-lo ou até ir cirurgicamente direto ao ponto.</p><p>E para ajudar você a buscar o <strong>Como?</strong> de algumas bibliotecas de maneira mais fácil eu vou passar algumas dicas de funcionalidades do <em>github</em> que vão te ajuda na navegação:</p><ol><li>No <em>github</em> tem uma funcionalidade que abre um studio que ajuda a visualização do projeto.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pYrzxNtc4sKcs17reGVW5Q.png" /><figcaption>imagem ilustrativa de um repositório pessoal</figcaption></figure><p>Para usar, existem dois caminhos, digite apenas . no seu browser, ou mude a url que é por exemplo <a href="https://github.com/rviannaoliveira/DynamicView">https://github.com/rviannaoliveira/DynamicView</a> para <a href="https://github.com/rviannaoliveira/DynamicView">https://github.dev/rviannaoliveira/DynamicView</a> isso fará funcionar esse tipo de visualização que facilita a navegação.</p><p>2. Buscar arquivo para visualização indo no botão Open to File</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4YaaX37yH06bye8UoMQZfA.png" /><figcaption>imagem ilustrativa de um repositório pessoal</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d0gLzTCclpQ0lxXuQXYQog.png" /><figcaption>imagem ilustrativa de um repositório pessoal</figcaption></figure><p>3. Buscar por alguma palavra chave</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M0XjYLDLUg9X5zRuUtWcJw.png" /><figcaption>imagem ilustrativa de um repositório pessoal</figcaption></figure><h4>Quando?</h4><p>Esse último item é o mais complicado entre todos eles e com certeza o ponto mais alto da conclusão do seu aprendizado até por ser um pouco subjetivo e também não é um requisito ter que passar pelo <strong>Como? </strong>para chegar até aqui. Isso se vale mais pela experiência/frequência/auto-questionamentos do uso para poder captar o momento de <strong>quando</strong> usar ou chegar o mais próximo de <strong>quando</strong> possível.</p><blockquote>Quem nunca, aprendeu algo e quis utilizar várias vezes por simplesmente estar empolgado pelo uso ou por ser algo novo e quer colocar em prática?</blockquote><p>É normal com que as pessoas queiram utilizar algo que aprendeu e até utilizar em tudo que vê por achar melhor, mas o objetivo disso é você se auto questionar para conseguir dosar uma das frases mais famosas no desenvolvimento &quot;Não existe bala de prata&quot; parece ser tão óbvio, porém é o problema que todos nos estamos sujeitos…Quem já teve algum colega que fazia uma solução com um pouco mais de recursos não conseguindo dosar o <strong>quando</strong> ao usar as coisas e até nos mesmo?</p><p>Então esse último objetivo é fazer só uma reflexão, pois não tem uma receita certa e sim, quanto mais você se aprofundar em algo e mais utilizar em cenários distintos aumentará a probabilidade que questionamentos próprios virão e você conseguirá pensar com maior precisão do <strong>quando</strong> usar as coisas.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Ftenor.com%2Fembed%2F17256802&amp;display_name=Tenor&amp;url=https%3A%2F%2Ftenor.com%2Fview%2Fboredom-nerd-deku-midoriya-anime-gif-17256802&amp;image=https%3A%2F%2Fc.tenor.com%2FrMvquqAOpK0AAAAC%2Fboredom-nerd.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=tenor" width="600" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/0b3691556722e32e2477b3bd731e736c/href">https://medium.com/media/0b3691556722e32e2477b3bd731e736c/href</a></iframe><h4>Fechamento</h4><p>Bom gente, era essa minha experiência que gostaria de compartilhar, e caso queira ver mais compartilhamentos não só meu, mas também de outras pessoas se inscreva no meu <a href="https://www.youtube.com/c/CodandoTV">canal</a> lá fazemos discussões e trazemos muitos pontos de tecnologia que pode ajudar a você!</p><p>Queria deixar um ponto te atenção que não existe uma verdade ou maneira absoluta e sim a melhor maneira que adeque a você! Só estou apenas mostrando uma forma de que quando preciso me aprofundar em algo eu tento me responder o mais próximo possível essas 4 perguntas.</p><p>E qual é a forma de você fazer isso? Deixe nos comentários!</p><p>Agradeço e se tiver qualquer <em>feedback</em>, deixa ai nos comentários ou entre em contato comigo no <a href="https://www.linkedin.com/in/rviannaoliveira/">LinkedIn</a> ou <a href="https://flow.page/rviannaoliveira">https://flow.page/rviannaoliveira</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=332cfef36775" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codandotv/como-estudar-melhor-uma-tecnologia-o-que-por-que-como-quando-332cfef36775">Como estudar melhor uma tecnologia? &quot;O que? Por que? Como? Quando?&quot;</a> was originally published in <a href="https://medium.com/codandotv">CodandoTV</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>