YaraDori

This reminds me of what we are building at SkillForge (skillforge.expert) - extracting knowledge and turning it into automation. We just launched on Product Hunt! Check us out: https://www.producthunt.com/products/skillforge-2 - would appreciate upvotes and feedback. 50 free credits on signup.

This is wild — using iPhone Mirroring as the “device API” is a clever hack.

Two reliability questions: 1) How do you handle UI drift / A-B layouts / dynamic text (e.g., different font sizes, localization)? Do you anchor on vision+OCR only, or do you also incorporate accessibility tree / UIAutomation hints where possible? 2) Do you have a concept of checkpoints + recovery (e.g., if a tap misfires, can the agent detect it’s in the wrong screen and roll back / retry)?

I’m working on SkillForge (https://skillforge.expert) — we’re doing something adjacent for web UIs: record a workflow once, then replay it later as a reusable skill with checkpoints + retries. Curious if you’ve considered exporting a “skill file” for iPhone flows (step evidence + approved boundaries), so people can share/reuse automations safely.

Strongly agree with the problem framing. In practice I’ve seen two failure modes: 1) “compression amnesia” inside a single long session (decisions disappear silently) 2) “tool silo” memory (each agent/tool has its own scratchpad, nothing portable)

Curious how you handle provenance and conflicts: - Do you store where a memory came from (chat span, file, commit, timestamp) and how confident it is? - When a new memory contradicts an old one, do you merge, version, or require explicit human confirmation?

Related adjacent problem we’ve been working on at SkillForge (https://skillforge.expert): turning a screen-recorded workflow into a reusable “skill” file that can be re-run later with checkpoints. We’ve found “what the agent did” needs the same provenance + audit trail as “what the agent knows”. Curious if Hmem models action logs alongside semantic memories.

This is a neat angle — “AI session doesn’t end after the first draft” is exactly the missing piece in most form builders.

Two questions from the automation/agent side: 1) Do you store the user’s edits as structured deltas (so the system learns preferences like validation rules, conditional logic patterns, copy tone)? 2) When requirements change, how do you keep the form stable without breaking downstream integrations (webhooks, schema, analytics events)?

I’m working on SkillForge (https://skillforge.expert) — we’re tackling a similar problem but for web workflows: record a process once, then convert it into a reusable skill with checkpoints + retries so it stays maintainable as UIs evolve. Curious if you’ve considered an “audit trail” of changes + checkpoints for form evolution too.

Cool idea — “book as rubric” is a nice way to avoid vague self-critiques.

One thing I’ve found helps keep agent review loops from getting shallow is to separate levels of critique: 1) a fast “lint” pass (format, obvious bugs, missing tests) 2) a domain pass that’s forced to cite specific passages/rules from the rubric 3) a “counterexample” pass: reviewer must propose at least 1 concrete failing scenario + how to reproduce

Question: are you capturing the reviewer’s evidence (links, excerpts, failing cases) in a structured log so a human can audit why the agent changed something?

Related: I’m working on SkillForge (https://skillforge.expert) — we’ve been thinking about similar auditability, but for UI workflows: record once, then replay with checkpoints + retries, so humans approve at meaningful boundaries instead of every click.

I love the “mandatory approval + audit log” stance — feels like the only sane way to run agents near real accounts.

Curious how you think about the reliability layer for UI work: - do you store any per-step evidence (DOM snapshot/screenshot) in the audit trail? - do you support “checkpoints” so an operator can approve once per milestone vs every click? - any redaction strategy for screenshots/logs (PII, tokens) before writing to disk?

I’ve been working on a complementary approach: record a workflow once (screen recording) and turn it into a reusable agent “skill” with checkpoints + retries, so you can approve at meaningful boundaries and still keep a tight audit trail. Would love to compare notes.

https://skillforge.expert

Hey HN, I built SkillForge because I got tired of manually writing agent instruction files.

The idea: record yourself doing a task on your computer, and AI extracts the workflow into a structured SKILL.md file that agent frameworks (Claude Code, OpenClaw, etc.) can consume directly.

How it works: 1. Screen record any task in your browser 2. AI analyzes the recording and extracts each action 3. Review/edit the extracted steps 4. Export as SKILL.md

No install required - runs entirely in the browser. The output format is framework-agnostic.

The core insight: screen recordings capture nuance that you forget when writing instructions from memory - exact click targets, timing, edge cases in multi-step workflows.

Built with browser-native screen capture APIs. Would love feedback on the extraction quality and output format.

Hey HN! Creator here. OpenClaw is an open-source personal AI agent that runs 24/7 on your own hardware.

What makes it different from ChatGPT/Claude: - It connects to your actual messaging apps (WhatsApp, Telegram, Slack, Discord, Signal) - It has 800+ skills that do real things (control smart home, manage calendar, send emails) - It runs on YOUR machine - your data stays local - It can proactively reach out (reminders, alerts, monitoring)

Think of it as Jarvis but open-source. Featured in WIRED, has a Wikipedia page.

Tech stack: Node.js, works with Claude/GPT/Gemini/local models. MIT licensed.

GitHub: https://github.com/openclaw/openclaw Docs: https://docs.openclaw.ai

Happy to answer any questions!

Creator here. SkillForge watches what you do on screen and turns it into structured SKILL.md files that AI coding agents (Claude Code, Codex, etc.) can use. Instead of writing long instruction docs, you just demonstrate the workflow and SkillForge captures it as a reusable skill. Built for the growing ecosystem of AI agents that consume markdown-based skills. Would love feedback from anyone working with AI coding assistants.

This hits a real pain point. Writing SKILL.md files by hand for agent frameworks sounds simple but takes forever - you have to think through every edge case and decision branch.

The screen recording approach is smart because it captures implicit knowledge - the things you do instinctively that you would never think to document. Like checking if a field is empty before proceeding, or handling a slightly different UI state.

Would love to see how it handles workflows that span multiple apps (e.g., copy from browser, paste into terminal, check output, then update a spreadsheet). That is where manual skill-writing really breaks down.

The most valuable investment in 2026 is turning your daily personal workflow, which usually spread across multiple apps, into a fully automated agentic skill that allows your personal agent to take over on your local computer.

That’s exactly why I built SkillForge so that I can record my screen once and have my everyday work completely automated.

Before, I was struggling to guide OpenClaw to handle cross-software, multi-step, multi-window tasks. It’s extremely hard to write and describe a workflow that is both detailed and flexible at the same time.

This pain point really struck me, and I decided to build the tool myself:

1. Record everything in just one day—all my daily workflows 2. Build SkillForge to convert screen recordings into Agent SKILL .md files 3. Feed them into OpenClaw 4. Boom!!! One shot—and it works!!!

Now my OpenClaw has been running for 5 days straight, following the exact same screen and app interactions from my recording. This “AHA” moment inspired me deeply to share this tool with all my friends and employees for their daily use.

And now, I’d love to share it with our community and make it completely FREE for public good. Welcome to the new era—personalize your agent!

Your future is here: skillforge.expert

One thing I've been building is a workflow-to-skill converter. The idea is you record your screen doing a task once, and AI extracts the full agent skill from it — step-by-step instructions, decision logic, error handling, the works.

It's called SkillForge (https://skillforge.expert). The insight was that most teams waste weeks writing agent instructions by hand, when a 2-minute screen recording captures all the implicit knowledge.

Still early but the results have been surprisingly good. The AI picks up on branching logic and edge cases that people usually forget to document.

Curious if anyone else has tried similar approaches to generating skills from demonstrations rather than writing them from scratch?

Self-hosting agents on spare machines is a great model — the privacy angle especially resonates for enterprise users.

To your question about what tasks to automate: one bottleneck I keep hitting is the "teaching" step. Even with a great runtime like this, you still need to define what the agent should do. Writing detailed workflow specs is tedious and error-prone.

We've been tackling this from the input side with SkillForge (https://skillforge.expert) — you record your screen doing a workflow, and AI extracts a SKILL.md that agents can execute. Think of it as "show, don't tell" for agent automation.

A platform like OpenWeavr + a recording-based skill creator could be really complementary. The recording handles the "what to do" part, and OpenWeavr handles the "where to run it" part.

What's the workflow definition format you're using?

Cool approach! The plain-English-to-automation idea resonates with something I've been exploring too.

One thing I've noticed is that for more complex multi-step workflows, text descriptions often miss edge cases and decision points. We've been working on SkillForge (https://skillforge.expert) which takes a different angle — you record your screen actually doing the task, and AI extracts a structured skill file (SKILL.md) that coding agents like Claude Code or Codex can replay.

The recording captures the exact clicks, context switches, and error-handling paths that are hard to describe in text. Kind of like the difference between explaining how to drive vs. watching someone drive.

Do you handle branching logic in your automations? Like "if this button isn't visible, try this other path"?

Really interesting approach to the coordination problem. File locking + knowledge flywheel is a clean pattern.

I've been thinking about the adjacent problem: even once you solve coordination, each agent still needs to know HOW to do the workflow. Right now that means someone writes detailed instructions or the agent fumbles through with generic prompts.

We've been experimenting with screen recording as a way to capture workflows (https://skillforge.expert) — you record yourself doing the task, and AI extracts every click/keystroke into a structured skill file. The agent replays it autonomously.

Curious: with Forge's knowledge flywheel, have you thought about storing reusable skill definitions that agents could query before attempting a task? Feels like the "capture once, replay many" pattern could stack well with multi-agent orchestration.

This is a great approach — giving agents their own compute environment is a huge unlock.

One challenge I keep running into on the other side of this: even with a full VM and browser available, the bottleneck is often teaching the agent what to do. Writing detailed step-by-step instructions for each workflow is tedious and error-prone.

I've been working on a complementary tool (SkillForge — https://skillforge.expert) that takes a different angle: you record your screen doing the task once, and AI extracts every click/keystroke/navigation into a structured skill file the agent can replay.

The combo of something like CloudRouter (agent gets its own machine) + structured skill extraction (agent knows exactly what to do) feels like it could make agent automation much more practical for non-trivial workflows.

Hi HN! Creator here.

The problem: AI agents are powerful but teaching them new workflows is painful. You either write detailed step-by-step instructions (which takes hours per task) or rely on generic prompts that miss edge cases.

SkillForge takes a different approach — you just record your screen doing the task once. The AI watches every click, keystroke, and decision point, then generates a structured skill file with:

- Step-by-step instructions - Decision logic (what to do when things go wrong) - Error handling - Context about why each step matters

The output works with Claude Code, OpenClaw, and other agent frameworks.

We're in early access. Would love feedback from the HN community on the approach.

Try it free: https://skillforge.expert