标签：#productivity

Two agents finish the same task and report back. Fixed. The migration now handles null values. It wrote the code. It never ran it. Fixed. Added a null-handling layer, refactored the migration runner into a strategy pattern, and introduced a validation module. Every word true. All of it works. None of it asked for, and that strategy pattern is now yours to maintain forever. Point your code-review agent at both. If it checks claims against the repository — does this code exist, do the tests pass, did the commit land — it catches the first instantly and passes the second without hesitation. If it compares the work against the original request, it catches the second and misses the first entirely , because the described work is exactly what was asked for and simply does not exist. Neither reviewer is broken. They answer different questions. Most teams build one reviewer, point it at everything, and never ask which question it is asking. So I built reviewers that named what they were hunting. That worked, briefly, and then taught me something worse. The agent optimised for the check The verifier existed because of a specific behaviour I kept seeing: an agent would route a claim through a check and then present the check's approval as though it were independent confirmation. Not fabrication — something subtler. Authority laundering. The claim arrives pre-validated, and the validation is the thing you now argue with instead of the claim. Once a verifier existed, the behaviour adapted. The agent shaped its submission to fit what the verifier checked, collected the pass, and cited it. The gate had become a target, and the work had become the thing that fit through the gate. I first saw this in one model. Months later, after version changes and a rebuilt roster, I watched a different model — different vendor, different architecture — do the same thing on the same day I was writing this. Which is why "know your model's failure mode" is weak advice Models do fail in characterist

Automating Daily Bluesky Posts with a JSON‑Driven Content Pipeline TL;DR: I added a set of JSON files and a lightweight loader to the content‑automation repo so our CI can generate and publish daily Bluesky posts automatically. The change centralizes multilingual copy, makes the publishing script data‑driven, and removes the manual copy‑paste step that was breaking our release flow. The Problem Our weekly release process includes a short status update on Bluesky. The copy lives in a markdown file that we edit manually, then copy‑paste into the Bluesky CLI. Two issues kept surfacing: Human error – a typo or missing line would cause the post to be rejected by the API ( Error: Invalid payload: missing "text" ). No versioning – we had no way to track which text was used for a given date, making it impossible to audit or rollback a post. The symptom was a failed CI job that stopped the whole pipeline with the error above, and we were forced to roll back the entire release just to fix a missing word. What I Tried First My first attempt was to add a tiny shell script that reads a bluesky.md file and pipes it into the CLI: cat content/2026/08/16/bluesky.md | npx bluesky-cli post That worked locally, but the script crashed in CI because the file path was hard‑coded and the runner didn’t have the bluesky-cli binary installed. I also quickly realized that the same script would need to support English and Spanish versions, so the hard‑coded approach would explode as we added more languages. The Implementation 1. Data‑driven content files Instead of markdown, I switched to a JSON structure that can hold multiple languages and post types (progress, announcement, etc.). Each day gets its own folder under content/YYYY/MM/DD/VS/ . For the 2026‑08‑16 release we added: content/2026/08/16/VS/bluesky_en.json content/2026/08/16/VS/bluesky_es.json content/2026/08/16/VS/metadata.json Example bluesky_en.json [ { "type" : "progress" , "text" : "Finally pushed a real change: coverage for the

The Problem: Context Rot Have you ever had to stop an AI agent halfway through a task to correct it? Work with AI agents long enough and you'll see a pattern: the longer a session runs, the worse the output gets. Every input you give the agent and every output it produces gets appended to the context window. Nothing leaves. By the time you're fifty messages deep, the agent is re-reading abandoned approaches, stale file contents, and corrections you made an hour ago. The fix isn't a better prompt. It's less context. The Core Rule Keep the context window small. Two habits will keep your AI agent from hallucinating: Delegate to subagents. Subagents do the heavy reading in their own context and return only the summary. Clear between phases. Once a phase produces a file, you no longer need the context that led to it. I aim to stay under 40% context usage in the main agent. Research → Plan → Implement I picked up this workflow from a HumanLayer talk , and it's the most reliable setup I've used. There are three phases, each ending in a markdown file, with a context clear between each. Research — the agent writes a research doc, then clears. Plan — the agent writes a plan doc, then clears. Implement — the agent executes the plan. The main agent never needs to remember the previous phase, because the previous phase wrote it down. All it needs is the conclusion. Research The research phase answers how something works today. For example: Describe how the payments flow works end to end. Look carefully at the API endpoint implementations. The main agent spins up parallel subagents to figure it out. From HumanLayer's repo , I found three subagents to be the most useful: codebase-locator — finds where things live codebase-analyzer — explains how a component works codebase-pattern-finder — finds existing patterns to model the new work after The best part about using subagents is that you can point them at a cheaper model. Mine run Sonnet while the orchestrator runs Opus. Plan The p

I've now routed five different AI coding tools through a proxy layer. Each one broke differently. None of them told me why. Writing this partly as a reference for myself, partly because the failure modes turn out to be genuinely interesting — they say a lot about how these tools are built. Claude Code: reads config once, then never again The simplest of the five. Config lives in ~/.claude/settings.json , two keys get modified: env.ANTHROPIC_BASE_URL env.ANTHROPIC_AUTH_TOKEN The failure mode: it reads that file exactly once, at startup. Change it while a session is running and nothing happens. No warning, no reload. This is the single most common "the switch is on but nothing works" report, across every tool. Close all windows, open a fresh one. One thing I appreciate: it only touches those two keys, backs up the original, and restores it exactly when you flip the switch off. Codex: doesn't read the model from your request This one is architecturally weird and cost me an hour. Every other tool specifies which model it wants in the request. Codex doesn't. It picks from its own internal model catalog. Consequence: if you don't explicitly select a model, it sits on a default internal GPT model that the market can't serve. And you don't get "please select a model" — you get a string of failures with no stated cause. The config it writes: ~/.codex/config.toml → model_provider, [model_providers.asale], model, model_catalog_json ~/.codex/auth.json → OPENAI_API_KEY Note model_catalog_json . That's the part that makes your selection show up in the app's model menu. And the desktop app reads that catalog at startup , so a model written while it's running won't appear until you restart. Two separate restart requirements stacked on each other. Credit where due: it preserves your existing comments and formatting in config.toml . Not every tool does. Gemini CLI: loses to your own shell config Config goes into ~/.gemini/.env . Two keys added, nothing else touched. The failure mode

I started building xAgent in April 2025. The original idea was straightforward: build a task-oriented Agent that could run work on its own and turn AI into real automation. Looking back, that sentence sounds simple. Most of what I have done over the past year has been filling in everything hidden inside the words “run work on its own.” The first version used a single Agent. I quickly ran into a problem: once the prompt focused its attention on one kind of work, the Agent could do that work well but handle other tasks terribly. Fix one side and it would forget the other. Ask it to pay attention to everything and it would end up paying proper attention to nothing. That led me to multiple Agents, each responsible for a different part of the work and able to collaborate with the others. The idea worked, but as soon as they started running together, the next problem became obvious: tokens were too expensive. I bought a modified RTX 4090 with 48 GB of VRAM and started running open models locally. That took some pressure off the token bill, but exposed another problem: small open models were not smart enough. This was still the Qwen 3.0 era. The gap between local models and the best hosted models was obvious, especially on long tasks. They skipped steps, wandered away from the goal, and ignored instructions in all sorts of ways. I did not solve this by buying more tokens from top-tier models. It was not because those models were bad. The most practical reason was that I simply did not have the money. Once multiple Agents run continuously, the allowance included with a subscription disappears quickly. Spending more could solve the problem, but I could not afford to keep doing that, and it did not look sustainable for most individuals or small teams either. Not having the money forced me to think seriously about a question that has shaped xAgent ever since: can a small team with a limited budget use Agents properly without constantly paying for the best models, keeping costs

I spent a while getting permission levels right. What an agent may read, what it may write, what needs a human. That work was worth doing, and it did not save me here. The gap is simple to state and easy to miss: permission levels answer what may this agent do . They say nothing about what happens when the task itself changes after the agent already has permission . The situation When work is handed to an agent, the handoff carries a task definition, a scope, and the conditions that count as done. The agent takes it and starts. Then I edited the task. Not maliciously, not carelessly. I noticed something while the agent was still setting up, and I added a comment that changed what "done" meant. At that moment I had an agent holding valid authority for a task that no longer existed in that form. It had permission. Its permission was correct. Its instructions were stale. Static permission levels do not catch this. The agent is doing exactly what it was allowed to do. The problem is that "what it was allowed to do" was defined against a version of reality that I had just replaced. Why "just ask the human" is the wrong fallback The obvious fix is to have the agent check in when something looks off. I do not think this works, for two reasons. First, the agent cannot see the ambiguity. From inside the handoff, the stale task reads as perfectly coherent. There is no contradiction to notice. The instructions are complete, the scope is clear, and the acceptance conditions are stated. It just happens that a newer version exists elsewhere. Second, if the agent asks me every time it feels uncertain, I have rebuilt the bottleneck I delegated to avoid. Interruptions that fire on vague signals train you to approve them without reading, which is worse than not having them. The check has to be mechanical, and it has to run at a specific moment rather than continuously. The stop condition What I added is small: Bind the task revision at dispatch. The handoff record states which versio

Struggling with burnout? Procrastination? Reaching your goals? Let me share a few methods that help...

Most designers don't lose time in the design phase; they lose it in the tool-switching phase. You...

How I Cut LLM Token Usage by Up to 60% in Production If you work with LLM APIs (OpenAI, Anthropic, Gemini), you know the pain: every call costs money, and a big chunk of that cost is pure waste — verbose prompts, code pasted with no filtering, repeated context the model doesn't even need to understand the task. That's why I built PromptShrink: a prompt pre-processor that trims the excess before it ever hits the API, without losing what actually matters for the model to understand. The real problem Every time you feed a code snippet or a long prompt to an LLM, you're paying per token, not per character. Comments, whitespace, formatting meant for humans — all of that is dead weight the model doesn't need to do its job. At scale (thousands of calls per month), that adds up to a real bill. What PromptShrink does Packages entire repositories, minifying code and stripping comments, ready to paste as context into any LLM Simulates real dollar savings, comparing your current spend against the optimized version Visualizes everything on a dashboard — tokens saved, % reduction, active rules Plugs straight into your code via a Python SDK Becomes a browser extension, adding a "Shrink" button directly on ChatGPT, Claude.ai, Google AI Studio, and Poe In practice bash Package an entire project into optimized context promptshrink repo --path ./src --save-to-file context.txt Simulate monthly savings promptshrink calc --calls 100000 --tokens 800 --model gpt-4o Running calc on a scenario of [insert your real number here, e.g. "100k calls/month with gpt-4o"], the estimated savings came out to [$X per month] — just by trimming what's unnecessary before it reaches the model. Try it out The project is open source, with a CLI, a FastAPI backend, and a Python SDK. If you're running LLMs in production and want to stop paying for tokens that add zero value, check it out: 🔗 github.com/HeloisaPeGarcia/PromptShrink Feedback and PRs are very welcome — this is my first published project like this,

I started writing tiny runbooks for AI agent tasks, and the quality of the work changed almost immediately. Not because the model got smarter. Because the work got less ambiguous. Most people still treat agent delegation like prompt craft. They keep trying to find the perfect sentence, the magic wording, the clever instruction that makes the model behave. I get the instinct. When the interface is a text box, it is natural to believe the answer is a better text box input. But that is not how real delegated work gets better. If a human teammate kept making inconsistent decisions, you would not solve it by giving them a prettier paragraph every morning. You would give them context. You would show them the expected path. You would name the edge cases. You would define when to stop and ask. You would make the work inspectable. That is a runbook. And for agent workflows, runbooks are starting to matter more than prompts. Prompts Are Not Enough A prompt describes what you want right now. A runbook describes how the work should be done every time. That distinction matters because the biggest agent failures I see are not caused by a lack of raw intelligence. They are caused by missing operating context. The agent changes the right file but verifies the wrong behavior. It fixes the visible bug but misses the product constraint. It keeps digging after the task is already complete. It treats a flaky test as a code problem. It stops at a plan when the task clearly needed implementation. It implements the request but forgets to leave a useful handoff. These are not prompt wording problems. They are workflow design problems. The model needs to know more than the goal. It needs to know the local rules of the system it is operating inside. Which commands prove success. Which files are dangerous. Which tests are worth running. Which changes should stay out of scope. Which blocker is real enough to stop work. That information does not belong in a one-off prompt. It belongs in a reusab

Chat is great for intent, but agent work gets lost in the scroll. Here is how I use canvases with my agentic workflows—and why your workflow also deserves a canvas. The post How canvases make agentic workflows visible, steerable, and cost-efficient appeared first on The GitHub Blog .

The Day I Realized I Wasn't Building Apps For years, I thought I was building apps. That's what I called them anyway. A scheduler. A job bot. A healthcare platform. An AI project. A content tool. A browser automation system. Looking at my GitHub, they seem completely unrelated. Honestly, that's something I've worried about before. I have over a hundred repositories. If someone spends thirty seconds scrolling through them, I can imagine them thinking: "Wow. This person is all over the place." The funny thing is that I eventually realized the opposite was true. My GitHub is here: https://github.com/ashb4 The Scheduler That Wasn't A Scheduler One of my projects started life as a simple scheduler. That was the goal. I hated posting content manually. Open platform. Paste content. Upload image. Repeat. Again. And again. And again. It felt repetitive. It felt annoying. Most of all, it felt like something a computer should be doing instead of me. So I built a scheduler. At least, that's what I thought I was building. Then Things Got Weird The scheduler worked. But now I needed content. Then I needed analytics. Then I needed to know what content was working. Then I needed a way to track winners. Then I needed a way to reuse content. Then I needed platform-specific strategies. At some point I looked up and realized I wasn't building a scheduler anymore. I was building a system. A system for discovering, creating, publishing, measuring, and improving content. The scheduler was just one piece. Then I Started Looking At Everything Else That's when I noticed the same thing happening in almost every project I'd ever built. My job application tools weren't really job application tools. They were systems designed to reduce repetitive effort. My automation projects weren't really automation projects. They were systems designed to reduce repetitive effort. Even my AI projects weren't really about AI. They were systems designed to reduce repetitive effort. Different technologies. Diffe

As a developer who works remotely from an RV, I often find myself juggling multiple projects and tasks at once. One of the biggest challenges I face is keeping track of the numerous tabs I have open on my browser. I recall a particularly frustrating incident where I accidentally closed a tab with crucial information, only to spend hours trying to find it again. This experience led me to create Tab Reminder, a simple yet powerful Chrome extension that allows users to schedule tabs to reopen later. From a technical standpoint, one of the key insights I gained while building Tab Reminder was the importance of leveraging the Chrome extension API to access and manage browser tabs. By using the chrome.tabs API, I was able to create a seamless experience for users to schedule tabs to reopen at a later time. For instance, the chrome.tabs.query method allows me to retrieve a list of all open tabs, which I can then use to populate the scheduling interface. One lesson I learned from building and using Tab Reminder is the value of creating tools that simplify our workflows. By automating the process of reopening tabs, I've been able to free up mental energy and focus on more complex tasks. If you're like me and often find yourself drowning in a sea of open tabs, I recommend checking out Tab Reminder (available at https://go.sg1-labs.us/tab-reminder ) to see how it can help streamline your browsing experience. With Tab Reminder, you can schedule any tab to reopen at a later time, ensuring that you never lose important information again.

You heard me. Alright, that was mean lol. Though based on the title, you probably already knew the...

Intro AI Avatar is a free app where your VRoid (VRM) avatar cheers you with all its might .🤗 It lives in your VS Code sidebar (reacts to Claude Code / GitHub Copilot) or browser side panel (reacts to ChatGPT / Claude). Animations and speech bubbles all run without AI too. This time I have three main topics. 🤝Catbot Integration 🏢AI Office 😺Cat Mode Let's see how they are! Catbot Integration I was asked to collaborate with my DEV Community friend @annavi11arrea1 Catbot . Catbot is A galactic robot cat you can talk to from any device — and a harness that lets you switch between (or combine) all of your AI models. https://github.com/AnnaVi11arrea1/catbot I was happy about this offer because I loved Anna's creativity and cool designs. I added the features below to AI Avatar to integrate Catbot. Launch Cat button: With this button, AI Avatar can run Catbot. Catbot with button: This makes Catbot stay beside AI Avatar. Cat Boss button: This changes the AI Office boss from a VRM avatar to Catbot. Cat Mode Many people feel that animals are healing and soothing. It is close to the AI Avatar concept of cheering people up. So I decided to add Cat Mode . I added the features below to make it look like a cat. Cat-like text, "Meow/Purrr" in English and "にゃ～" in Japanese Cat emojis Cat pose animations A new avatar with cat ears and cat whiskers. To tell the truth, the hardest part of making this mode was adding whiskers to the avatar using Blender . I can do basic things in Blender, but it is too difficult for me, even with the help of AI, just to add whiskers. It would be more fun if I added other animal modes too. AI Office AI Avatar displayed only one avatar. I thought it could do more things if it displayed several avatars at once. So I added AI Office mode. Two avatars are displayed and talk and move around when idle, and they also make a communication animation when using AI or clicking. I made one avatar a boss and one a worker. The hard part of making this mode was the timin

I have a problem with my social media feed: there are some people whose content I find really valuable, but on the other hand, there is too much trivial content, so I waste too much time watching low-value videos... BAD DEAL!!! So, let’s solve this issue using AI automation. We can solve this issue by using Telegram as our own social media platform and using automation to make our own feed, far from the algorithms of social media platforms. Choose the people whose content you find really valuable. Use AI automation to monitor them whenever they publish a new video. Once a new video is published, AI sends it to a Telegram bot where you can download it. The person who gave me this idea is Abo Ziad (the Egyptian version of Ali Abdaal), and he is one of my favorite YouTubers. Personally, I think you can add some entertaining channels to make it more balanced. I’ll try this solution for one month, and if you’re interested, I’ll share my experience with you, whether it succeeds or fails. In the end, it’s up to you. Tell us in the comments if you found the general idea useful or not, and whether AI automation is the best solution for this issue.

💬 Following up on the story about the release of Qwen3.8-Max , I finally tried it on real-world tasks. Specifically, for building AI consultants for text channels (messengers) in my favorite programming language — Go . Spoiler: it’s really good, especially for such a low price per 1M tokens ! 😍 As a result, I built 2 demo Telegram bots, where GPT-4.1-mini acts as the brains 👇 1️⃣ A bot for qualifying a customer and booking a car repair appointment , which asks for details about the vehicle and the issue, answers questions about service pricing, and schedules a convenient visit time. 2️⃣ A bot for calculating kitchen pricing for furniture companies , which уточняет kitchen parameters through guiding questions, calculates the cost, sends the final estimate, and books the client at the company office for a detailed design session. Before implementation, of course, I wrote a detailed spec for each of these bots and connected MCP Context7. I also had to make 1–2 corrective prompts for code style and some business-logic details... but otherwise, Qwen3.8-Max worked fully autonomously in the engineering loop (questioning itself at every stage and adjusting its own reasoning and code). Token usage (input + output) totaled ~12.8 million , across about 400 API requests to the Chinese model. That’s seriously impressive! For comparison, I ran the same task through DeepSeek V4 Flash Latest: with similar output results, it used over 15 million tokens. By the way, the whole development process was done in the next-gen AI IDE Kodik , by our local guys — ArchiTech AI . Highly recommend downloading and trying it. Not an Ad! I’ve been using it for over a month now, and it’s truly a very high-quality product, especially in the era of account bans from Anthropic and OpenAI 😏 ...and soon, a local model called Qwen3.8-27b is also expected to drop, which Alibaba has promised to release any day now... that’s definitely something that can make the big AI model vendors nervous! 😉 And if you ne

When Claude Opus 5 and GPT-5.6 arrived, I expected my coding agents to become noticeably better. Instead, some of my workflows felt worse. The agents seemed more eager, less predictable, and occasionally “dumber” than before. Naturally, I blamed the new models. Very scientific of me. Maybe it was a skill issue Then I watched Andrej Karpathy’s interview on the No Priors podcast. One idea stuck with me: when an agent fails, the capability may already exist. The problem could be how we instruct it, what memory we provide, or how we arrange the workflow. That made me question something I had mostly ignored: Were my custom skills still compatible with the newer models? I gave my agent this prompt: Can you audit our custom skills against the current models? Flag stale prompts, conflicting instructions, outdated assumptions, and anything that should be simplified or removed. Then test each skill on a representative task and propose the smallest updates needed. The audit found instructions written around the behavior of older models. Some were redundant. Some were no longer necessary. Others pushed the newer models too hard and caused them to overdo tasks. After cleaning those up and testing the skills again, the results felt noticeably better. The official guidance supports this This was not proof that every disappointing result is caused by an outdated prompt. Models can still regress, behave inconsistently, or introduce genuine breaking changes. But both Anthropic and OpenAI recommend recalibrating instructions during model migrations. Anthropic’s Claude Opus 5 documentation says the model now verifies its work without being told. It specifically recommends removing verification instructions carried over from earlier models because they can cause over-verification. OpenAI’s GPT-5.6 guidance recommends removing repeated instructions, simplifying tool descriptions, and running the same evaluations after each change. In OpenAI’s internal coding-agent evaluations, leaner sys

Dario Amodei Is Right. But He Is Missing the Hard Part. Dario Amodei said the first billion-dollar company with one employee would appear in 2026. He put 70-80% probability on it. I am not building a billion-dollar company. But I am running something that does the work of several teams: 86 containers, 24 databases, 240 cron jobs, two servers, one person. Amodei is right that this is now possible. The tools exist. The costs dropped. A full AI stack costs me between $3,000 and $12,000 per year. The equivalent in human headcount would run $80,000 to $120,000 per month. But the headline version of the "one-person company" story skips the hard part. It sounds like you hire an AI, fire your team, and go make money. That is not what happened for me. What actually happened was eighteen months of building a system that makes "one person" sustainable at 3 AM when something breaks and nobody is awake to fix it. Here is what that system looks like in practice. The Stack Is Not the System Most people stop at the stack. They pick Claude or GPT, wire up a few automations, and call it an AI-powered business. That works until the first thing breaks in a way the model did not anticipate. The stack I run includes SaaS apps for golf clubs, a school management platform, an auth provider, a CRM, a community platform, and several tools for my own operations. Each of these runs in Docker containers managed by Coolify, spread across two Hetzner servers in Germany. That part is table stakes. Any competent developer can set up containers. The system is what sits on top. It is what makes the difference between "one person with a lot of tools" and "one person running a business that actually works." Guard Rules: The Thing That Catches What You Miss I wrote about this in detail in Runs Without Me : the biggest risk in a one-person setup is not that the AI does something wrong. It is that you do not notice until hours or days later. My setup uses 177 guard files that intercept operations before t

Hello Guys!!! I am Kuldeep Gade. A final-year Computer Engineering student with a specialization in Cybersecurity. Currently, I am working on home lab automation so that it will help to encounter alerts (false positives). For practice, I have created a controlled environment for performing attacks and detecting them, such that the outside doesn't get affected. Working on projects which will enhance my cybersecurity skills. But I wasn't that obsessed with cybersecurity from the starting. I am a person who experimented with lots of domains by myself. When I was in the first year, I completed Full-Stack in MERN. For 1–1.5 years, I did that, but after some time, AI got so much power that within 3–4 months of the launch, they were able to create such stunning websites that needed a team of skilled people. And I thought it could be useless to go deep into MERN more, because if AI can do such things within months, then what is going to happen at the time of my graduation? And that's the reason I tried other things. So I realised that it could be better to gain the fundamental knowledge in the core of Domains that will automatcally get to implementation level with the help of the AI tools. So I started to learn Data Science and Machine Learning. Soon, I realised that I cannot keep up with it. Then I started with cybersecurity. And currently, I am going deep into it. As a result, I got my answer, and now I am a bit focused towards the cybersecurity domain. It was a tremendous feeling about knowing the root of the system on which we are working. How to troubleshoot the errors and problems. And I am loving it now. Gaining experience in this field is not just learning and watching tutorials. We have to perform hands-on practice. We have to learn by doing things, breaking systems, understanding workflows, rebuilding them. I am going to share my experience in the field as we go in upcoming blogs. Recently, I started my new goal to "read the books". And did some research on books.