标签：#productivity

For decades, developers were judged by one thing: How much code they could write. The best programmers wrote faster. Debugged faster. Built faster. That era is ending. The next generation of developers won't spend most of their time writing code. They'll spend it directing AI. Welcome to the age of the AI Orchestrator. The Evolution of Software Development Software development has always evolved. First, developers wrote machine code. Then came assembly. Then high-level languages. Then frameworks. Then cloud platforms. Then DevOps. Each evolution removed repetitive work and let developers focus on bigger problems. AI is simply the next step. But this time, it isn't replacing a tool. It's becoming a teammate. Coding Is Becoming a Smaller Part of the Job Building software isn't just writing code. A typical project includes: Understanding requirements Researching documentation Designing architecture Writing code Reviewing code Debugging Testing Writing documentation Deploying applications Monitoring production Fixing incidents Only one of those is coding. Everything else is coordination and decision-making. That's where AI is changing the game. From Programmer to Orchestrator Think about how modern teams work. A tech lead rarely writes every line of code. Instead, they: Assign work. Review solutions. Provide feedback. Make architectural decisions. Remove blockers. Developers are beginning to work with AI in much the same way. Instead of writing every function, they'll: Define the goal. Provide the right context. Choose the right tools. Review AI-generated code. Run tests. Improve weak areas. Approve the final result. The value shifts from typing code to guiding its creation. What Does an AI Orchestrator Do? An AI orchestrator doesn't ask one question and accept one answer. They manage a workflow. For example: Break a large project into smaller tasks. Give each AI the context it needs. Decide when to retrieve documentation. Decide when to search the codebase. Ask AI to g

At the beginning of June I started a “ Claude withdrawal ” challenge. The plan was to run MiniMax 3 for a month, to see if I can get the same level of quality, but at 5x less the price. Until then, Claude Code was my main driver, with MiniMax on the backup, for when I was running out of quota, or sometimes for code review. The monthly bill for Claude was $100 on the Max plan, whereas for MiniMax I would pay $20 for the Token plan. All in all, it seemed like an interesting experiment. Then, half way through the challenge, Grok came into the picture. I got a very interesting offer at $35 for 3 months, then $35/month. But Grok has something neither Claude, nor MiniMax can give me out of the shelf: video and image generations. The only unknown was if switching from Claude Code to Grok will still maintain the same coding power. So I instantly took the offer, and did whatever I had to do to understand if this was the right path. And here comes the “whatever I had to do”, in plain technical terms. Switching from Claude Code to Grok – the Actual Steps The switch itself was interesting because I didn’t want to lose the Claude Code interface. I like the harness. The way it works with my codebase, the commands, the flow. So I used a helper called cliproxyapi . It’s a small proxy that sits between the Claude Code client and whatever model you point it at. You run it locally, tell it to forward requests to Grok’s API instead of Anthropic’s. Then you launch Claude Code the same way you always do, but it talks to Grok under the hood. Here’s how it goes in practice. Step 1: Install the proxy. I used brew to install it, I’m on a Mac, and also because I wanted to have it started as a service. Step 2: Set two environment variables. One is the target API base URL, for Grok that’s something like https://api.x.ai . The other is your API key. "env" : { "ANTHROPIC_BASE_URL" : "http://localhost:8317" , "ANTHROPIC_API_KEY" : "cliproxy-local-key" } , Notice how we use “cliproxy-local-key”, be

Terminal-based AI agents have evolved considerably over the past few months, and several changes are significant enough that developers relying on these tools should be aware of them. Most notably, Google has begun retiring Gemini CLI for individual users in favor of Antigravity CLI — a closed-source successor that has drawn some pushback from the community that built out Gemini CLI's open-source ecosystem. Meanwhile, Claude Code has moved to the Opus 4.8 and Fable 5 models with a 1M-token context window, and OpenClaw, the open-source "always-on" agent, has grown into one of the most-starred projects on GitHub — alongside a documented CVE worth knowing about before deployment. I've just published an updated, fact-checked comparison covering: What actually changed with Gemini CLI's retirement, and what it means if you have scripts or CI/CD pipelines depending on it Claude Code's current model lineup, context window, and new Dynamic Workflows feature OpenClaw's architecture, extensibility via ClawHub, and the security considerations that come with deep system access A full feature-comparison table (cost, context window, open-source status, setup complexity) A practical case study walking through how all three tools can work together on a real project Would be curious to hear which of these you're using day-to-day, and whether the Gemini → Antigravity transition has affected your workflow. Full article here: Devlycan - Technology & Programming Insights Devlycan - Technology, programming, AI, lifestyle, and future trends—simple insights for the new digital generation. devlycan.com

TL;DR: I set up a Claude Code skill that checks in with me about my workday, asks follow-up questions, and saves a structured markdown file I can use as promotion evidence. Here's why it works, and how to build one in about five minutes. May 6th On May 6th I had an energy level of 2 out of 5. I got my Claude Certified Architect exam score back that day: 717 out of 1000. I needed 720. I missed it by three points. Four lines down in the same entry, my manager had told me: "your leadership is being felt around Artium. You're making a good impact." Here's the thing about that day: the bad number is vivid and self-evident. 717. Three points short. That number was going to live in my head rent-free for weeks. But the recognition? That quietly evaporates. Left to memory, May 6th is the day I failed the exam by three points. On the page, it's also the day my manager told me my leadership was landing across the company. The entry keeps the thing I'd lose otherwise. The Problem With Memory I've been bad at this for years. At performance review time, I'd stare at a blank document trying to remember what I'd actually done. I'd come up with four things instead of forty. My manager would advocate for me based on what she happened to see, which was never the full picture. The thing is, I did good work. I just didn't capture it. A few years ago I tried to solve this with Google Forms , a structured form I'd fill out at the end of each day that fed into a spreadsheet. It worked, kind of. The data was there, but it felt like homework. The form didn't ask follow-up questions. It didn't notice when I was being vague. I had to go somewhere specific to fill it out. And when review time came, I had to go back somewhere else to compile everything, figure out what mattered, and assemble it into something coherent. The friction wasn't just the daily entry. It was the whole chain: capture, retrieve, synthesize, present. I was on my own at every step. So I built something better. What I Built

Every sprint starts with optimism. The board is clean, the story points are perfectly balanced, and the team is ready to ship. Then, Tuesday happens. The CEO wants a "quick favor." A major client finds a critical bug in production. The marketing team urgently needs a landing page tweak. By Thursday, your pristine sprint board is buried under a mountain of "urgent" tickets that were never discussed in planning. This is Unplanned Work , and it is the silent killer of engineering velocity. Why Unplanned Work is So Dangerous It’s not just that unplanned work takes time. The real damage comes from context switching . When a developer is deeply focused on building a new feature, forcing them to stop, spin up a local environment for a different repository, debug a legacy issue, and then try to return to their original task destroys their flow state. A "10-minute quick fix" actually costs the company an hour of lost productivity. When this happens multiple times a week: Deadlines Slip: The tasks you actually committed to get pushed back. Burnout Increases: Developers feel like they are working hard but accomplishing nothing. Trust Erodes: Management wonders why the team can't stick to a timeline. How to Protect Your Team You cannot eliminate unplanned work completely. Bugs will happen, and production will break. But you can manage it. 1. The "Firefighter" Rotation Instead of letting unplanned work disrupt the entire team, assign one developer per sprint to be the "Firefighter" (or Batman/Support). Their only job for that sprint is to handle urgent bugs, ad-hoc requests, and unblock others. The rest of the team is completely shielded. 2. The 20% Buffer Rule If you have 100 hours of developer capacity, never plan 100 hours of feature work. Always leave a 20% buffer specifically for unplanned tasks. If no fires start, you can pull from the backlog. If fires do start, your deadline isn't destroyed. 3. Track the "Ghost" Tickets The worst kind of unplanned work is the kind that h

Every week I was burning the same hours doing the same thing: opening tabs, copying data, pasting it into a spreadsheet and starting over. The work was mindless. It was repetitive. It was exactly the kind of task that shouldn't require a human being in 2024. So I built an n8n scraper workflow that now handles all of it automatically — and here's exactly how I did it. The Problem Worth Automating Keeping product data current is non-negotiable for tech content research. Specs change. Prices shift overnight. Availability fluctuates without warning. Before automation, that meant manually visiting product pages and logging updates into a tracking sheet — a process that consumed three to five hours every single week. The inefficiency compounded fast. I missed updates between check-ins. Formatting stayed inconsistent across entries. The cognitive overhead of context-switching between dozens of tabs left me mentally depleted before I even reached the analytical work. Data collection wasn't just slow — it actively degraded everything downstream. Something had to change. Why n8n and Not Something Else I evaluated several tools before committing. Zapier is polished but expensive at scale and frustratingly rigid with custom HTTP behavior. Make (formerly Integromat) offers more flexibility yet its pricing model penalizes heavy usage quickly. Python scripts give you full control but demand ongoing maintenance and provide no visual debugging environment for non-engineers. n8n threads the needle cleanly. It's open-source and fully self-hostable so there are no per-task fees regardless of volume. Its visual node editor makes workflow logic instantly readable. Its native HTTP Request node handles custom headers, authentication and response parsing without a line of external code. For a scraping workflow that needs to stay reliable, repeatable and maintainable — n8n was the clear answer. Building the Scraper — Step by Step Step 1 — Schedule the Trigger Every automated workflow needs a

Originally published on productize.life . Quick answer: pm-skills is a marketplace of around 68 Claude skills for product management across 9 plugins, from strategy and discovery to market research and AI shipping. It is built by Pawel Huryn, author of the Product Compass newsletter. Each skill is not a loose prompt but a named, sourced framework, and one of them audits the gap between documentation and code, a PM lens built for the era of AI-written code. Last week I was reading through a run of repos that pack product work into skills. Some pick one topic and go deep. This one does the opposite: it is the broadest of the bunch. It is called pm-skills, by Pawel Huryn, the author of the Product Compass newsletter. He packs almost the entire product management craft into around 68 skills across 9 plugins, from setting strategy, running discovery, and researching the market, to analyzing data, executing, and shipping software that AI wrote. Usually something this broad ends up shallow. But when I actually opened it, it was not, and one skill in particular made me stop and look for a while , because it covers an angle that only recently became necessary in the era where AI writes code for us. I will tell it in three parts, starting with what it is , then why it is not just a prompt box , and closing with lessons for anyone building products . Terms, gathered once, right here skill a ready-made set of instructions an AI agent (such as Claude Code) can invoke, like a shortcut that wraps one way of doing a task. framework a ready-made way of thinking from the PM world, such as SWOT, JTBD, or RICE, that you once had to read a book to use well. plugin (category) a group of skills that belong to the same topic, such as the discovery category or the go-to-market category. PRD a product spec document that says what will be built, for whom, and how success is measured. Part 1: What pm-skills is It is a marketplace of around 68 Claude skills for PM, organized into 9 plugins, eac

Originally published on productize.life . Quick answer: gstack is an open-source (MIT) skill set that Garry Tan, president of Y Combinator, builds with every day. It turns Claude Code into a team of 23 specialists, CEO, engineers, designers, QA, and a release engineer, forcing every change through a multi-lens review before shipping. The point is not speed; it is taste written into software. Last week I was going through a repo that collects skills for coding, several of them. Most share one theme: helping AI write code in a systematic way, and faster. But one made me stop longer than the rest, called gstack, for two reasons. One: its owner, Garry Tan, president and CEO of Y Combinator, took the stack he actually builds with every day and opened it for free. Two: it does not sell "code faster," it sells "review before you ship." Once I actually opened it, it was not just a toolbox but one of the clearest examples of an idea I have been interested in for a while. On the day AI can write code very fast, the bottleneck of the work is no longer speed. I will tell it in three parts, starting with what it is , then what gstack believes , and closing with lessons for people who build products, not just people who write code . Terms, gathered here in one place agentic coding letting an AI agent run the coding work in its own steps, from planning to writing to review to shipping, not just autocompleting a line at a time. skill a packaged set of instructions an AI agent (like Claude Code) can call, like a shortcut that wraps one way of doing one thing. review lens reviewing one piece of work from several roles, for example as a CEO, an engineer, a designer. taste the sense and judgment of what is good and what is bad, what to build and what not to ship. The part that is still human. Part 1: What gstack is Garry Tan describes gstack in the README plainly, as the way he works. "It turns Claude Code into a virtual engineering team: a CEO who rethinks the product, an eng manager

If you're anything like me, your Chrome toolbar probably looks like a collection of tiny puzzle pieces. Grammar checker. Screenshot tool. Summarizer. Writing assistant. Code explainer. Translator. Email helper. At one point I had more than a dozen extensions installed. Chrome became slower, pages loaded later, and every extension wanted permission to "read and change all your data." Then I started experimenting with AI tools instead. Not everything was better—but some things surprised me. Here's what I learned after replacing most of my browser extensions with AI. 1. Grammar Checkers I used to rely on grammar extensions that constantly underlined my writing. Now I simply paste my draft into an AI assistant and ask: Improve grammar while keeping my writing style. The biggest advantage isn't fixing mistakes—it's preserving tone. Traditional grammar tools often make everything sound the same. AI can make your writing cleaner without removing your personality. 2. Article Summarizers This was probably the easiest replacement. Instead of installing a summarizer extension, I paste the article and ask: Summarize in 5 bullet points Give me the key takeaways Explain it like I'm a beginner What important details are missing? The last prompt is especially useful because summaries sometimes leave out important context. 3. Code Explanation This has become one of my favorite AI use cases. Instead of searching Stack Overflow for every unfamiliar function, I simply paste the code and ask: Explain this line by line Why was this approach chosen? Is there a better alternative? What's the time complexity? The answers aren't always perfect, but they're often enough to understand what's happening before diving into documentation. 4. Writing Commit Messages This is something I didn't expect AI to help with. Instead of writing: fixed stuff I can paste my git diff and ask for a concise commit message. Example: feat: add JWT authentication middleware fix: resolve login redirect loop refactor:

👋 Hey dev.to community, Last week I shipped a workflow I built for a friend who runs an online shop. He called me again a few days later with a new headache: he's drowning in Purchase Orders. Every single one gets opened by hand, the data typed into a Google Sheet, and that sheet uploaded into his ERP to update his numbers. Hours a week, pure copy-paste. So I built him something to kill that step. He uploads the PO PDFs through a simple n8n form, and a structured Google Sheet comes out the other end. He just downloads it and pushes it to his ERP. How it's set up: The form accepts multiple PDFs at once , so he can batch a whole stack instead of doing them one by one. Each PO loops through on its own so nothing gets jumbled. The extraction runs on the easybits Extractor node ( @easybits/n8n-nodes-extractor ). I set the field structure up in two parts: the header fields that appear once per PO (PO number, PO date, delivery date, mark for, PR number, reference no), plus an articles array for the line items, each holding article name, unit and quantity. That array is the key bit, it gives you one entry per row of the PO table, and I flatten it into one sheet row per article with the header details repeated on each. Two things I added because real documents are messy: Error flagging . If any field comes back empty, the completion screen lists which document and which field didn't extract cleanly, so he knows exactly which PO to double-check instead of trusting it blindly. Document name column . The original filename lands in the sheet next to every row, so if a number looks off he can jump straight back to the source PDF. Workflow JSON is on GitHub: https://github.com/felix-sattler-easybits/n8n-workflows/blob/c38749a68fd6ea4ae6ebff41789d35cceaacdef1/easybits-purchase-order-extractor-workflow/easybits_purchase_order_extractor_workflow.json Anyone else automating document-to-sheet data entry? Curious how you're handling the messy multi-line rows – that was the trickiest par

The conversation around Agentic AI often focuses on one goal: making agents more autonomous. More tools. More reasoning. More planning. More independence. It sounds like progress. But is more autonomy always the right answer? As software engineers, we rarely optimize for "more." We don't build distributed systems when a monolith is sufficient. We don't introduce microservices because they're fashionable. We choose architectures that balance capability with complexity. The same principle applies to AI agents. The question isn't "How autonomous can my agent be?" It's "How autonomous should my agent be?" Autonomy Is a Design Decision When people talk about autonomy, they often think of it as a feature that an agent either has or doesn't have. In reality, autonomy is a design decision. Every time we allow an agent to make another decision on its own, we are increasing its responsibility. That responsibility comes with benefits, but it also introduces new engineering challenges. More autonomy means the agent can adapt to situations that weren't anticipated during development. It can make progress toward a goal without being guided through every step. At the same time, it becomes harder to predict, validate, debug, and trust. Autonomy isn't free. Thinking in Terms of an Autonomy Spectrum Instead of treating autonomy as a binary concept, it helps to think of it as a spectrum. At one end are systems that simply generate responses. They have no authority to take action. As autonomy increases, agents begin suggesting actions, invoking tools, planning multiple steps, and eventually deciding how to achieve a goal with minimal human involvement. The important observation is that every step along this spectrum increases both capability and complexity. That's why the objective shouldn't be to reach the highest level. It should be to stop at the level your problem actually requires. More Autonomy Isn't Always Better Imagine building an internal HR assistant. Its primary responsibil

I used to waste hours tweaking and re-tweaking my AI model prompts. It was like trying to find a needle in a haystack—I'd make a change, run the code, wait for the results, and then... nothing. The output would be inconsistent, unhelpful, or just plain wrong. I'd try again with tiny modifications, rinse and repeat, until I was about to pull my hair out. It wasn't until I stumbled upon the concept of reusable prompt templates that everything changed. It was like a switch had flipped—my code started producing consistent results, and I finally understood why. No more guesswork, no more frustration. Just good old-fashioned productivity. A simple shift from writing one-off prompt strings to using reusable templates is the key to reducing prompt overhead, increasing consistency, and getting back to doing what we love—building amazing, AI-driven applications. From Chaos to Control: A Simple Example Let's make this tangible. Imagine you're building a feature to generate a short story, but for different characters. Before: The Inconsistent, One-Off Way Without a template, you'd likely write a new prompt each time, introducing small, unintentional differences that lead to wildly different results. Two separate prompts = inconsistent, unpredictable output prompt_for_alex = "Write a short story about a character named Alex who is trying to get to work on time, but keeps getting delayed in a busy city." prompt_for_jordan = "Generate a story about someone named Jordan. They're late for work and stuck in traffic in a big city." See the problem? The tone, wording, and details are different. You have no control over the consistency of the output. After: The Clean, Templated Way Now, let's use a single template. We define the core structure once and simply pass in the parts that change. Now, let's use a single template. We define the core structure once and simply pass in the parts that change. One template = consistent, predictable output story_template = "Write a short story about

Thomas Edison put it plainly: "To have a great idea, have a lot of them." Steve Jobs said something similar. "Creativity is just having enough dots to connect... to connect experiences and to synthesise new things." Both of them are saying the same thing. Your first idea is rarely your best one. The reason why people you call creative can come up with great ideas easily is that they have had more experiences or have thought more about their experiences than other people. So the question becomes: how do you get more ideas, faster? The Most Used Method for Applied Creativity The answer has a name. It was coined by advertising executive Alex Osborn in the 1940s. He called it brainstorming - using the brain to storm a creative problem, with each person in the room attacking the same objective. It sounds simple. Most teams think they already do it. Most of them are wrong. Real brainstorming is a structured process with rules. Break the rules, and you get something that looks like brainstorming but produces far fewer useful ideas. Why Most Brainstorming Sessions Fail Here is what kills a brainstorming session before it even starts. Someone says an idea. Someone else says, "That won't work." The room goes quiet. People stop sharing. That is it. That is the whole problem. When people fear judgment, they self-censor. They only say the safe, obvious ideas. The interesting ones, the ones that could actually lead somewhere, stay locked inside people's heads. Most teams have that one gaffer who has already decided which ideas are worth hearing before anyone has finished their sentence. Or the one who gives you the floor, listens patiently, and then quietly bins everything you said, not because it was bad, but because it was not theirs. Both types do the same damage. The room reads it. People stop sharing. And just like that, the best idea in the session never gets spoken. The goal of brainstorming is to get more ideas. That means the number one rule is: defer judgment . The Rule

I sat down to work for 2 hours. I actually worked for 45 minutes. Sound familiar? You open your...

Everyone keeps saying AI will let a solo developer take down the giants. And everyone keeps saying the giants will just absorb everything. Both takes are wrong , and I spent a while reading the actual 2025 data to figure out why. I pulled from four of the biggest developer datasets of the year: DORA 2025 State of AI-Assisted Software Development (Google Cloud, ~4,867 respondents) Stack Overflow 2025 Developer Survey (49,009 respondents) GitHub Octoverse 2025 (behavioral data across 180M+ developers) JetBrains State of the Developer Ecosystem 2025 (24,534 developers) Here's the honest synthesis. It's more useful than either hype narrative. The one-sentence thesis AI collapsed the cost of writing software to near zero. It did not collapse the cost of distribution, trust, support, or being liable when it breaks — and those are ~80% of what a software business actually is. So the effect isn't "solos beat giants." The effect is that the middle got hollowed out . The 10-person, VC-funded, me-too startup building a feature is the loser of this era — squeezed from below by a solo who ships the same thing for free, and from above by a giant who bundles it. Solos and giants both survive. The undifferentiated middle doesn't. "AI is an amplifier, not an equalizer" This is the single most important finding of 2025, and it comes straight from DORA: "AI's primary role in software development is that of an amplifier. It magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones." Read quickly, that kills the "AI levels the playing field" fantasy. AI rewards whoever already has good practices — not whoever is scrappiest. But read one layer deeper and it becomes the best available argument for the small team. DORA found the key enabler is independence of action — "the ability to develop, test, and deploy value independently, with little or no coordination cost." In an Adidas pilot they cite, teams in loosely-coupled architectures saw 20–30% produ

Pressing enter to accept model suggestions now takes less effort than scrolling past it. One keystroke, and the code is yours. Reading it, understanding it, deciding if it's actually right, that part hasn't gotten any faster. That gap, between how fast we can accept code and how fast we can actually understand it, is where things start to go wrong. The new shape of technical debt We used to know where technical debt came from. Tight deadline, cut corner, # TODO: comment that nobody ever revisits. Rushing was the cause, and we could at least point to it. Now you can build up the same kind of debt on a calm Tuesday afternoon, no deadline in sight, just six suggestions in a row accepted because they looked fine and the flow felt good. Nobody rushed you, and the code still ended up just as unexamined. Same debt, just a different excuse. "It works" is not the same as "I understand why it works" Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it? — Brian Kernighan, 1974 Fifty years later, the gap got wider. Kernighan was talking about code you wrote. At least you understood it once. A suggestion that compiles, passes the linter, survives code review and even comes with passing tests can still be standing on a wrong assumption that nobody caught, because nobody was reading it as code. They were reading it as output, and output that makes sense tends to get approved. Compiling is a low bar. Passing tests is a slightly higher one, depending on whether you wrote the tests, or its suggestion shaped or created those too. If it's the second, it's like grading its homework with its own answers. None of it tells you the logic is sound, that the edge cases are covered, or that it does what you actually needed, something we already learned every time we trusted code we didn't write. Somehow it's easy to forget it the moment the code appears inline, in our own edito

We started using Jira to manage our internal development workflow. At first it worked fine, but once we outgrew the free tier, the cost became hard to justify. At $15 per user per month, we were suddenly looking at a bill that did not match how we actually used the product. What we Built We created WannaTrack, a lightweight project management tool designed for small dev teams that do not need enterprise complexity. The goal was not to recreate Jira. It was to remove everything we did not use. Key ideas : minimal agile board with no clutter or heavy configuration simple issue tracking flow fast interface for daily development work minimal setup and no onboarding overhead Migration from Jira One of the biggest concerns was switching tools without breaking our workflow. So we built a Jira import tool that lets you migrate existing tickets into WannaTrack without manual effort. This allowed us to switch internally without downtime. Where it is now We now use WannaTrack daily for our own development workflow and are opening it up to other teams who feel the same pain with traditional tools. If you are a small dev team, indie hacker, or startup looking for a simpler issue tracker without overhead, you can check it out here: https://wannatrack.com

The goal is to start the day already briefed — not to spend the first hour becoming briefed. What follows isn't groundbreaking. It's just what pushing my own boundaries looks like in practice. The problem As a Tech Lead of a larger team, my mornings used to look something like this: open email, skim through multiple newsletters I subscribed to for staying current on AI and dev topics, switch to Slack, scroll through everything I missed, try to figure out what actually needs my attention, then check what code went into the repo in the last 24 hours. By the time I was done "catching up," a good chunk of the morning was gone. I knew there had to be a better way. Starting with Claude Cowork Claude's desktop app has a feature called Cowork, and within that, you can set up Scheduled tasks — automated tasks that run on a schedule. I set up two that run every morning: Newsletter digest: This one pulls in all the newsletters I received the day before and summarizes them for me, grouped by topic — AI-related first, then dev, then everything else. Instead of opening each email and scanning for what's relevant, I get a curated briefing in seconds. Slack summary: This gives me a full summary of yesterday's Slack conversations across channels, and more importantly, flags what actually needs my attention. No more scrolling through hundreds of messages trying to separate signal from noise. The only downside? The Claude desktop app needs to be open and running for these to kick in. It's not a dealbreaker, but worth knowing. I'll be honest — the idea wasn't entirely mine. When you set up a new Scheduled task in Cowork, a Daily Brief is literally the example they suggest. I just happened to already be poking around with something similar. A lucky coincidence. Taking it a step further with Claude Code One of the hardest parts of leading a larger team is keeping tabs on everything that changes in code. PRs get merged, features get shipped, bugs get fixed — and it's nearly impossible to

Bringing the ideas I've been thinking about for months into life has never been easier, thanks to AI agents. The basic intuition is—give it a prompt, it builds the whole feature, the result looks good. Done. It takes only minutes to build the same thing that would've taken hours otherwise. Yes, I know, everyone's doing that. Right? The reason I'm opening like this is to point out what happened afterwards. I tried to use the search bar, and it fired a request on every keystroke. Wait, what? I didn't do that. Of course I'd add a debounce here. But the agent didn't. Why? I didn't ask it to. I said—build me a search bar, and it built me one that works; but I didn't say exactly what I wanted. Also, I noticed that the search button changes color on hover, but I'd already told it not to do that. The agent forgot, it hallucinated. What's missing then? What was missing was I did not provide the agent with the exact decisions to work with the feature; or did not provide a proper reference point to fallback to, to remediate the hallucination. In other words, I did not provide it with a proper spec. Hence, it took the hidden decisions itself; even though it pulled the feature off. This is the core problem that Spec-Driven Development (SDD) solves. The Hidden Product Decisions Your AI Agent Is Making For You Here's what happens when you describe something to an AI agent and it generates code: lots of decisions get made. Let's take the search bar implementation as an example. Does the filtering happen on the client or the server? Does the URL update so results are shareable? What does an empty query show? Everything, or nothing? I tend to miss nitty-gritty details while reviewing tons of AI generated code in a short amount of time. The code works, the UI looks right, I move on… Every one of those is a decision that belongs to my product. If I don't make the decisions consciously, the agent takes them based on whatever pattern shows up most often in its training data. Take that se

Here's a scenario that plays out in engineering teams every day: you spin up a conversation with an AI tool to analyze some code, get a useful response, copy-paste the output, and close the tab. An hour later, you need a follow-up analysis — and you're starting from scratch. No context, no history, no continuity. Now multiply that by five tools running in parallel. ChatGPT for drafting, Claude for analysis, Copilot for code, a local model for sensitive data, maybe a custom agent for domain-specific tasks. The outputs are scattered across browser tabs, Slack threads, and clipboard history. Nothing connects. The AI tools themselves are capable enough. What's missing is the infrastructure to treat them as actual team members — with identities, workspaces, and accountability. The Identity Problem Every AI interaction today is anonymous. You talk to "the model," it responds, the session ends. There's no persistent identity, no accumulated context, no track record. This works fine for one-off questions. It breaks down the moment AI needs to participate in a sustained workflow — the kind where you need to know who did what, when, and how well. We've been building an open-source project called Octo (Apache 2.0, GitHub ) that approaches this problem by giving AI agents a proper identity system. In Octo, each AI agent is a Bot — a first-class entity with a name, a creator, a capability card, and a work history. A Bot isn't a chatbot wrapper. It's a structured identity: Creator binding : Every Bot is created by a human user and inherits a scoped subset of that user's permissions. The Bot acts on behalf of its creator, not autonomously. AgentCard : A structured capability declaration — what the Bot can do (coding, analysis, translation, design), at what level, in what domains, and with what constraints. Think of it as a resume that other team members can inspect before assigning work. Work history : Every task a Bot participates in gets recorded — completion status, quality sco