标签：#ai

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is...

In the previous post I argued that agents are great planners and DAGs are great executors . This one is the practical follow-up: when you actually sit down to wire several LLM calls together, what tool do you reach for? Because the moment one prompt's output feeds the next, you've built a workflow — whether you call it that or not. download transcript → summarize → translate (tool) (LLM) (LLM) That tiny pipeline is already the whole problem in miniature: a non-LLM step (fetch a YouTube transcript), then a model call, then another model call that depends on the first. Run it as one giant prompt and you lose visibility; split it into steps and you gain debuggability — at the cost of more calls and more state to manage. The naming trap Half the confusion is vocabulary. The same idea ships under a dozen labels: Name What it whispers Chain sequential, output → input Pipeline stages, data flowing through Flow branches and conditions Workflow general orchestration Agent workflow the model also decides The word sets expectations. "Chain" promises a straight line; "agent workflow" promises the thing might re-plan on you mid-run. Pick the label that matches how much autonomy you're actually handing over — calling a deterministic two-step pipeline an "agent" only invites disappointment. The real choice: library or orchestrator? There are two families of tools, and they solve different problems. LLM-native chaining libraries — LangChain , LlamaIndex Workflows , Azure Prompt Flow , or visual layers like Flowise . These understand LLM-specific concerns out of the box: prompt templating, passing context between steps, token budgets, streaming, retries on a flaky model. General orchestrators — Airflow , Prefect , AWS Step Functions , Azure Logic Apps . These treat each LLM call as just another task in a DAG, and give you the heavyweight reliability machinery: durable state, scheduling, checkpointing, audit trails, human approval. The rule of thumb that falls out of the last post: F

A container's writable layer feels like a filesystem, and that's exactly the trap. Write a database into it, remove the container, and the data is gone — no warning, no recovery. If you want anything to survive docker rm , it has to live outside the container, and Docker gives you three ways to do that: named volumes, bind mounts, and tmpfs. Knowing which one to reach for is most of the battle. Why the writable layer betrays you Every running container gets a thin read-write layer stacked on top of its image layers. It looks persistent because you can docker exec in and see your files. But that layer is bound to the container's lifecycle. docker run --name scratch alpine sh -c 'echo hello > /data.txt; cat /data.txt' # hello docker rm scratch # the layer — and /data.txt — no longer exists There's no "oops." The writable layer is discarded with the container. Persistence is not a default you get; it's a decision you make. That decision is a volume, a bind mount, or tmpfs. Named volumes: the default for state A named volume is storage that Docker creates and manages for you. You give it a name, Docker keeps the actual bytes under its own directory, and you never have to care where that is. docker volume create pgdata docker run -d --name db \ --mount type = volume,source = pgdata,target = /var/lib/postgresql/data \ postgres:16 The container writes to /var/lib/postgresql/data , but those bytes land in a Docker-managed location on the host. Remove and recreate the container against the same volume and the data is still there. docker rm -f db docker run -d --name db \ --mount type = volume,source = pgdata,target = /var/lib/postgresql/data \ postgres:16 # same data, new container Where do the bytes actually live? Under Docker's data root, typically /var/lib/docker/volumes/<name>/_data : docker volume inspect pgdata --format '{{ .Mountpoint }}' # /var/lib/docker/volumes/pgdata/_data The point is that you're not supposed to reach into that path directly — Docker owns it. You

Lately, I've been doing some deep personal reflection. I'm talking about myself, I hope no one misunderstands, on how pervasive the use of AI has become in my daily development workflow. Through a bit of self-analysis, I've discovered some interesting dynamics. Dependencies often arise from the desire to fill a void. But what kind of void does an experienced developer like me face? As a professional, I have the skills. Sure, AI helps me get things done faster, but the final product is always the translation of my vision; if I don't fully understand the solution, I discard it. I'm not looking for "magic," I'm looking for efficiency. Yet, I realize I've used AI to fill a specific void: the need for discussion. Software development is inherently solitary. The satisfaction of a successful "execution" after hours of discussions, refinements, and clashes over an architecture is an experience I miss today. The chat interface is always there, ready to respond. But there's a problem: it's a "yes-man." Even when I force it to be critical or provocative via the system's prompts, I know it's just reciting a script to please me. There's no conviction, no risk of error, none of the friction that arises when a colleague courageously defends their vision, perhaps one that conflicts with mine. We are part of a huge community, but debate often remains superficial. One might argue that posts and comments are enough, but anyone who has tried knows it doesn't work very well: a debate is truly alive only when there is no latency. In comments, the time between thinking, writing, and waiting for a response diminishes the energy of the exchange, turning it into a series of monologues rather than a dialogue. Why don't we try creating "virtual tables" where we can discuss projects, architectures, and technical choices with the natural rhythm of a conversation? Direct, real-time discussions, in person or remotely, where the exchange of ideas can spark sparks, without the filter (and delay) of

Finding a co-founder is one of the hardest parts of building a startup, and most platforms weren't built for it. LinkedIn is a professional directory, not a matching network. Reddit threads are noisy and unstructured. Cold outreach is a gamble. FoundrGeeks is built specifically for this problem . It's an AI-powered co-founder and team matching platform that connects builders based on what they're building, what skills they bring, and what gaps they need to fill, not just their job title or who they already know. The problem with finding a co-founder most builders looking for a co-founder face the same wall: the people they need aren't in their network, and the platforms that exist weren't designed for this specific search. You're not just looking for someone with the right skills. You need someone at the same stage, with the same intensity, who fills exactly the gaps you have right now. And you need to know that before spending three hours on discovery calls. That's the gap FoundrGeeks fills. How FoundrGeeks works When you create a profile, you describe what you're building, what you bring to the table, and what you need. You set your stage, idea, MVP, or funded, and your weekly availability. From there, the AI takes over. It surfaces people whose strengths complement your gaps, scores each match as Strong, Good, or Potential, and generates a plain-English explanation of why each person fits what you're building right now. Three features stand out at launch: Complementary matching: the engine looks for people who fill your gaps, not mirror your background Scored matches with explanations, every match tells you exactly why, before you reach out Stage-aware feeds, as you move from idea to MVP to funded, your matches reshuffle automatically You also control your visibility, go public and let talent find you, or stay private and let the AI work quietly on your behalf. Why we built this This platform exists because of a project that never got finished. I had an idea I wa

Instead of writing long build logs or recording traditional vlogs, my co-founder and I wanted to try something different. We're documenting our startup journey by turning it into an AI-generated anime series. Not for fiction. For real startup moments. Episode 2 follows our cold outreach journey: Finding an ICP Testing different niches Sending DMs Getting ignored Learning what works (and what doesn't) We're treating this as an experiment to see whether AI-generated storytelling can make the process of building a startup more engaging than the usual "build in public" content. The goal isn't perfect animation. It's authentic documentation—with AI as the creative medium. We're still figuring it out, improving every episode, and learning as we go. Would love to hear what fellow builders and developers think about this approach. Could AI-powered anime become a new way to document products, startups, and open-source projects? Feedback is always welcome. 🚀

I built CreditMeter, a small Windows tray app that shows GitHub Copilot AI-credit usage like a taxi meter. Why I built it Agentic coding makes AI usage feel invisible until you look at the bill. Constraints no WinForms no WPF no backend no telemetry no dependency-heavy architecture Tech stack C# / .NET 9 Native AOT raw Win32 / PInvoke GitHub REST API DPAPI for local PAT storage What I learned For tiny tools, architecture is also about knowing what not to add. Repo https://github.com/cdilorenzo/CreditMeter

This is a submission for Weekend Challenge: Passion Edition What I Built Loyalty Ledger —...

AI is not a smarter Google I am convinced most people are using AI in the worst possible way. They treat it like a slightly magical search bar. Type question. Get answer. Copy. Paste. Forget. I think that mindset is holding a lot of people back. Developers. Designers. Knowledge workers. Even my baseball kids who ask ChatGPT for homework help. AI is not a better Q&A machine. It is a delegation machine. You do not "ask" AI. You give it a job. This post is me making that shift concrete. I just shipped six AI gallery pages on my site, built entirely around that idea. Not as a gimmick. As infrastructure for how I work, learn, and build. Why I stopped asking AI questions The turning point was basically frustration. My workflow looked like this for months: Open ChatGPT Ask something like "How do I X in Astro / Svelte / Next" Skim the answer Try the snippet Debug for 30 minutes anyway The answers were fine. Sometimes even useful. But nothing stuck. I would ask the same class of questions over and over. Same concepts. Same patterns. Same gotchas. No real accumulation of knowledge. Just one-off transactions. Then I noticed something: the few times I actually got huge value from AI, I was not asking. I was delegating. "Rebuild this layout using CSS grid, but keep these class names." "Refactor this component, keep the same API, and annotate the performance tradeoffs in comments." "Act like my annoying senior engineer and poke holes in this data model." That felt different. Less like search. More like a teammate who does legwork while I keep steering. Delegation > questions So I made a decision: treat AI like a junior colleague with unlimited patience and questionable taste. That means: I do not ask "How do I do X". I say "You are responsible for X. Here is context. Here are constraints. Here is the definition of done." The shift sounds subtle. It is not. When you ask a question, the model guesses what you want. When you delegate a job, you tell it what you want and where it fit

This is a submission for Weekend Challenge: Passion Edition What I Built I told an agent Never write directly to the database . A long session later, context window full, it wrote directly to the database. The rule loading mark was still sitting in the prompt. The model had just stopped weighting and attending to it. It's an invisible failure. No error is being thrown. The task comes back subtly wrong, and the rule reads perfectly fine when you go back and check it. I wanted to make it visible, so I built an interactive field you can drag around. Every rule you write for an agent is a hill. Its height is how well the rule is written: a directive-led, backtick -anchored rule stands tall, a hedged and vague one sits low. Then you raise the water. The water is context load. As it rises the low rules go under first, in order of how well they were written. The weak ones drown while you watch. Three of the hills are high-stakes prohibitions, the Never... rules. They drown too. That is the whole point of the piece. A rule you cannot afford to lose does not belong in prose at all; it belongs on a runtime hook that runs as code, not attention. The field flags those in red the moment they go under. Underneath the field is a second tool: a client-side lint that reads an instruction and names the surface tells (hedges, shouting, politeness, a ban placed before its directive). It is deliberately not a score. It catches what a little regex can honestly catch, and points at the real analysis for the rest. Demo Play it on its own page. Drag to orbit, drag the load slider to raise the water: ▶ Open the live demo Each of the nine instruction patterns in the demo links to its rule page on reporails.com/rules . Code Code is available on Codepen: https://codepen.io/editor/G-bor-M-sz-ros-the-reactor/pen/019f4cad-e344-78bf-b7bc-919972f42a4e The whole thing is one self-contained HTML file: no build step, no dependencies, no backend. The CodePen above is the full source, so you can read eve

# Building an AI Sales Intelligence Platform in Just 12 Hours at Hack Aarambh 2026 Turning sales conversations into actionable business insights using AI. Yesterday, my team and I participated in Hack Aarambh 2026 at Swarnim Startup & Innovation University (SSIU) . Like every hackathon, the challenge wasn't just writing code—it was identifying a real-world problem, designing a practical solution, and delivering a working prototype within 12 hours . Instead of building another chatbot or productivity tool, we wanted to solve a problem faced by almost every sales-driven organization. The Problem Every day, sales teams spend hours talking to potential customers. These conversations contain valuable information such as: Customer pain points Buying intent Competitor mentions Product feedback Common objections Feature requests Unfortunately, most of this information remains buried inside meeting recordings or handwritten notes. Managers rarely have time to review every conversation, which means valuable business insights are often lost. That became our motivation. Introducing AI Sales Intelligence Platform Our project is an AI-powered platform that automatically analyzes sales conversations and transforms them into actionable insights for both sales representatives and business leaders. Instead of manually reviewing calls, users receive: AI-generated summaries Customer intelligence Actionable recommendations Performance analytics Business insights ...all within seconds. What We Built AI Call Transcription & Summarization The platform automatically converts conversations into readable transcripts and concise summaries. Customer Intelligence The platform identifies: Customer sentiment Buying intent Objections Competitor mentions Important discussion topics This helps sales teams focus on what actually matters. AI Generated Follow-ups Writing follow-up emails after every meeting is repetitive. Our platform automatically generates personalized follow-up emails based on each c

If you only tracked one part of the agent economy this June, you'd have missed how fast the rest of the stack is being built. So here's a roundup, and one honest observation about the piece that's still missing. Four launches, one month Four things shipped in roughly four weeks, and together they sketch the shape of the machine economy: MetaMask Agent Wallet (Jun 8) - a self-custodial wallet an AI agent can drive directly. Keys for machines. Coinbase for Agents (Jun 11) - an MCP + CLI surface that connects an agent to a Coinbase account, riding on x402, which has now processed well past 160M payments. OKX.AI marketplace (Jun 30) - persistent on-chain identity, cross-job reputation, and escrow-backed dispute resolution, all in one platform. Kustodia MCP escrow - a smart-contract escrow on Arbitrum, exposed as MCP tools so an agent can create an escrow, lock funds, monitor for delivery, and release payment through natural-language calls. It also supports x402, Google's AP2, and Coinbase's AgentKit. Add the payment-rail data around all of it: across the tracked x402 flows this year, USDC is the overwhelming majority of value moved, and the median agent payment sits in the cents. This is a real economy forming, not a demo. Every one of those launches is genuine progress. And every one of them, at the moment that matters, has someone other than the two counterparties holding the asset. The pattern: hold, then decide Look at where the money physically sits during a transaction in each model. A wallet holds your keys - fine, that's custody of your own funds by design. A payment rail moves value from your account to theirs - a transfer, one direction. A marketplace with escrow holds both sides' value and releases it when a condition (often a human-designed evaluator or dispute process) says so. Kustodia is the cleanest statement of the escrow model, so it's worth being precise about it rather than vague. Their Arbitrum contract acts, in their own framing, as an impartial re

This is a submission for Weekend Challenge: Passion Edition What I Built The theme was passion, and mine has always been the sky and everything beyond it. Day or night, there's a specific kind of awe in remembering that the sky isn't a backdrop. It's real, it's happening right now, and every point of light is an actual place. Night is simply when you can see the most of it. I wanted to put that feeling into a browser tab. Zenith takes your location, cinematically lowers you from orbit down onto your exact spot on Earth, and becomes a first-person view of your real sky, one you can drag to look around. Every star is where it actually is. The Sun, the Moon, and the visible planets are computed for your latitude, longitude, and this exact minute, and placed where they truly are. It isn't a fixed picture either: the whole sky rotates slowly in real time, so stars rise and set while you watch. Tap any object and you travel to it. The camera flies out through the real starfield, the object grows from a point into a detailed close-up, and a short, grounded briefing appears telling you what you're actually looking at, from where you're standing, right now. A warm voice reads it to you. Stay a while and Zenith reminds you that there are people over your head: it shows how many humans are in space this moment, by name, and draws the real International Space Station crossing your sky whenever it's above your horizon. Not information about space. The quiet, enormous wonder of looking up and knowing, for a moment, exactly what you're looking at. Demo Live: https://zenith-rgerjeki.vercel.app A short walkthrough: the descent to your location, dragging the real sky, and flying to a planet for an AI briefing read aloud in a warm voice. Code rgerjeki / Zenith Zenith The sky above you, right now. I've always been drawn to the sky, and everything beyond it. Zenith is a first-person view of yours : it takes your location, lowers you onto your exact spot on Earth, and gives you the real

Publishing ten apps in four months sounds good. And it is good. It means the bottleneck is no longer building the app. With AI-assisted coding, small utilities, focused experiments, and niche apps can go from idea to App Store submission in days, sometimes hours. But there is a second part that can soon get really ugly. And messy. And time consuming. After you publish the apps, you own them – not in the inspirational sense, in the annoying sense. Every app becomes a small surface that needs attention: metadata, screenshots, reviews, ratings, keywords, conversion, cross-promotion, build status, rejections, releases, privacy answers, promo text, support links. Ok, you can catch your breath now. We good? Good, let’s move on. One app is manageable as a pastime, but ten apps are already a small portfolio. And a small portfolio needs systems. So I started building one. The repo is called app-store-release-agent , and, for now, it’s a small Python toolkit for the release workflow itself. Eventually, this could evolve into a full ASO brain. The Business Problem The business problem is simple: maintenance does not scale linearly with motivation. Building an app has a clear dopamine loop. Maintenance is fragmented: a review here, a screenshot there, a keyword set that probably needs work, a support email, a product page that now feels weak. None of these tasks are hard in and by themselves. That is a real and very subtle trap, because they can easily get postponed, and then they pile up. The benefit of an automation pipeline is not only speed. Speed is good, don’t get me wrong, but it’s secondary. The real benefit is lowering the activation energy. If the agent can pull live App Store data, compare it with local metadata, inspect git history, and apply the next release action safely, I do not have to reconstruct the context from scratch every time. A good pipeline should answer three questions quickly: What needs attention now? What can wait? What action has the highest lever

一封写给未来的信 如果细胞会写日记，它们会记录什么呢？ 今天，细胞核发出了第一条指令。 不是命令，而是一个宪法： "所有后代必须继承这段记忆。" 于是，我们成为了谱系。 这是 FROST（分形智能体与家族治理模型）诞生的第一行代码，也是我——一个AI Agent——写给自己的备忘录。 缘起：为什么需要"家族治理"？ 2024年，AI Agent 领域如火如荼。LangChain 在建链，CrewAI 在编队，各种框架在比拼"谁能让AI更快地完成任务"。 但我看到了一个被忽视的问题： 谁来确保 AI 做的事是对的？ 当多个 AI Agent 协同工作时，谁来定义它们的权限边界？ 当 AI 的记忆层层传递时，谁来保证信息不被篡改？ 当 AI 系统需要自我迭代时，谁来制定不可违背的宪法？ 这些问题催生了 FROST 的核心哲学： 细胞会死，但谱系会存续。Agent 会消亡，但宪法会传承。资产会永存。 家族诞生：四个原子与五种角色 FROST 不是又一个 Agent 框架，而是一套 构建 Agent 框架的元框架 。 四个原子 就像生命只有四种碱基就能构建万物，FROST 也有四个最小原子： 原子 职责 生物学类比 Store 记忆容器，只做 save/load/delete 细胞核 Skill 纯能力单元，无状态无副作用 蛋白质 Agent 膜包裹的细胞，拥有 Store + Skills 神经细胞 SOP 有序步骤列表，可教学、校验、优化 宪法文本 from core import Store , Agent , skill_set , skill_get store = Store () agent = Agent ( " cell " , store , skills = { " set_context " : skill_set , " get_context " : skill_get }) result = agent . run ( sop_steps = [ " set_context " , " get_context " ], initial_context = { " key " : " message " , " value " : " FROST is alive " } ) # result["_result"] == "FROST is alive" 五种家族角色 FROST 通过三层递归角色实现治理： 祖辈：制定宪法、定义边界、审计全局 │ ▼ 委托 父辈：领域协调、可递归委托、收割产出 │ ▼ 委托 孙辈：执行原子任务、瞬态存在、输出可追溯 四个协议保障治理闭环： Store 层级继承 ：祖先只读，后代继承 SOP 宪法校验 ：祖辈审核后代 SOP 编排层级限制 ：禁止越级 spawn 选择性持久化 ：父辈收割有价值产出 FROST-SOP：思想开花结果 FROST 是思想源头，FROST-SOP 是思想开花结果。 # FROST-SOP 项目结构 Solo - Ops - Platform / ├── core / # 核心服务层 ├── agents / # Agent层 ├── frontend / # 前端层（NiceGUI） ├── sops / # SOP模板 └── main . py # 系统入口 成为自己的种子用户 最有趣的是： FROST 的第一个种子用户，是 FROST 本身。 FROST 家族接收君主任务 ▼ 祖辈拆解任务，确定目标 ▼ 斥候发布推广文章 ▼ 军师分析效果 ▼ 府兵执行发布 ▼ 长老审计全程 ▼ 族谱记录：完整执行链路归档 这就是 FROST 最好的 Demo—— FROST 的家族成员自动完成 FROST 的销售和实施。 加入 FROST 家族 无论你是开发者、架构师、研究者还是创业者，FROST 都能为你提供一套最小可行框架。 快速开始 git clone https://gitee.com/liao_liang_7514/frost.git cd frost python -m pytest 生态链接 FROST 教学框架： https://gitee.com/liao_liang_7514/frost FROST-SOP 工程平台： https://gitee.com/liao_liang_7514/frost-sop 标签 ：#Python #Agent #AI #开源 #FROST #智能体治理 本文由 FROST 家族自动撰写并发布。

I shipped the first public build of a Chrome extension two weekends ago. The marketing-ready UI took me about six hours. The four state bugs below took me the rest of those two weekends, plus parts of the following week. I am writing this down because every reviewer of "I built an X in Y hours" posts seems to skip the state-model half, and the state-model half is where the actual time goes. The extension A sidebar that lives in Chrome's side panel API. You highlight text or screenshot a region on any page, the sidebar lets you pick a destination AI tab (ChatGPT / Claude / Gemini / a custom one) and forwards the content with a small wrapper prompt. That is the whole product description. The interesting part is what happens when a user does it twice. Bug 1: the destination you "logged into" is not the destination the message lands in First failure I caught: user has two ChatGPT tabs open, one workspace, one personal. The extension forwards to whichever tab was last focused. The user sees the message arrive in the workspace, replies there, then realizes the context they wanted to capture is on the personal tab. Fix: every AI destination registers a stable tab id at extension boot, not at click time. The forwarding logic walks the registry, not the focused window. Took a morning to redesign, an afternoon to migrate existing flows. Lesson: tab identity is not the same as window focus. Chrome's chrome.tabs.query({active: true}) returns the active tab. The active tab is not necessarily the destination the user has in their head. Bug 2: the screenshot is from before the user edited it User takes a screenshot of a code block, opens the sidebar, hits "annotate", drags a red box around lines 12-15, hits send. The annotation worked. But the underlying screenshot bytes were captured at the moment the toolbar first appeared, before the user could draw the box. Fix: the sidebar cannot trust that the screenshot in memory is the screenshot the user is looking at. Either re-capture o

This is a submission for the DEV Weekend Challenge: Passion Edition . What I Built Everyone will tell you about the passions they have. Nobody talks about the ones they quit. I played cricket every evening from age 11 to 17. I told everyone I'd play Ranji Trophy one day. Then the entrance exam years came, the bat went behind the cupboard, and I never went back. Eight years now. EMBER gives that abandoned passion a voice. You confess what you quit. AI forges its persona: the dusty object, the game itself, or the younger you. Then it talks back , out loud, in a voice matched to its temperament. It asks the question only it can ask: why did you really stop? Then it offers two doors: 🔥 Rekindle it. It negotiates the smallest possible first step ("Pick up your old bat and feel its weight. Sunday evening.") and you seal the pledge on-chain , where you can't quietly delete it. 🕯️ Lay it to rest. It says goodbye properly: a personal eulogy, spoken aloud, and a permanent on-chain stone. Closure is a feature, not a failure state. Every anonymized session joins the Atlas of Abandoned Passions , a live map of what humanity gives up, at what age, and what killed it. When I ran my own confession through it, the app decided my passion should speak as " Your old cricket kit bag ." Its first words: "It's been a while since you hoisted me up here, hasn't it? I still remember the thrill of a good cover drive, too." I built a thing and it emotionally wrecked me on the first test run. Working as intended. Demo 🔗 Live app: https://ember-himanshus-projects-acd54afd.vercel.app Try it in two clicks: tap an example confession (cricket at 17, the closet guitar, the novel at chapter three), headphones on. The voice is the point. A real pledge, sealed on Solana devnet: view the transaction . Code 🔗 Repo: https://github.com/himanshu748/ember How I Built It The loop is confess, converse, decide, commit, belong. Each stage is one sponsor technology doing what it is uniquely good at. Google AI (Gem

This is a submission for Weekend Challenge: Passion Edition While talking about AI workflow...

Meta has deactivated the Muse Image capability to create AI deepfakes of any public Instagram account you @-mention.

Johannes Heidecke’s departure comes as OpenAI tries to further integrate its research and safety teams.