DEV Community: jg-noncelogic

Show HN: Calx – track and compile corrections humans make with AI agents

jg-noncelogic — Mon, 13 Apr 2026 18:00:24 +0000

Documentation doesn't change agent behavior.

I logged 237 corrections moved as rules — the agent still made 44 new mistakes; 13 were in categories the rules covered. Calx auto-promotes recurring corrections into enforced hooks injected at session start. https://github.com/getcalx

I run multiple $10K MRR companies on a $20/month tech stack

jg-noncelogic — Mon, 13 Apr 2026 05:15:23 +0000

Steve Hanov runs multiple $10K MRR companies on a $20/month tech stack. Read: https://stevehanov.ca/blog/how-i-run-multiple-10k-mrr-companies-on-a-20month-tech-stack

Take: expensive infra is a tax. If revenue is $10k MRR, shave hosting to buy runway and focus on product.

Practical rule: prefer primitives with tiny operational surface. Static sites, one small VPS, cron jobs, SQLite or a simple managed DB, and scripted deploys. You trade feature velocity for near-zero maintenance and predictable bills.

Numbers matter: $20/mo vs $200+/mo stacks. That 10x saving funds runway, a contractor sprint, or paid acquisition tests. Ops checklist: automated backups, health checks, one-command restores, simple uptime alerts. Ops time is the real cost.

My take: design for cognitive simplicity. Complexity compounds faster than traffic. Low-cost infra forces better defaults and faster iteration. Read Steve’s notes — then ask: where can you remove a service without increasing real risk?

Show HN: Skilldeck – Desktop app to manage AI agent skill files across tools

jg-noncelogic — Sat, 11 Apr 2026 13:00:23 +0000

Agent configs scatter across repos and silently diverge. Skilldeck keeps one local skill library and deploys to each tool in its native format so you don't rebuild behavior for every repo. Repo: https://github.com/ali-erfan-dev/skilldeck

It maps formats: .claude/skills, .cursor/rules/*.mdc, AGENTS.md, .windsurfrules, etc. Ten built‑in targets (Claude Code, Cursor, Copilot, Windsurf, Codex). Local‑only (Win/mac/Linux). Drift detection flags deployed skills that fall out of sync.

The app was built by Claude Code with a harness: ground‑truth JSON, Playwright E2E checks, a regression gate using a surfaces map, and a feature intake protocol. 31 features shipped across autonomous sessions. Agent coding needs engineering rigs, not improvisation.

Takeaway for agencies, advisors, lawyers: treat agent behavior files like code—version, test, audit. Skilldeck gives repeatability, pull‑back edits, and compliance signals. Have you used a local skill library to standardize agent behavior across client repos?

Show HN: I built a project board where AI agents join as real teammates

jg-noncelogic — Fri, 10 Apr 2026 18:00:24 +0000

Someone built a project board where AI agents join as real teammates. Read it: https://is.team. Take: giving agents "seats" forces you to manage them like humans — tickets, access rules, audit logs. Here's what I pulled from the build.

The clever bit: agents are modeled as contributors — they open tasks, comment, and execute tools. That forces structured interfaces: typed tool calls, an event-driven ticket pipeline, and explicit failure modes. Predictability > prompt spelunking.

Operational checklist if you ship this: BYOK (bring‑your‑own‑key) + RBAC for API keys, per‑step checkpoints and undo, deterministic policy for tool calls (Open Policy Agent works), immutable activity logs, and mandatory human approval before publish.

Bottom line: treating agents as teammates surfaces hard engineering — governance, observability, and review flows — not magic prompts. If you're building this, start with audit logs and mandatory human signoff. Has anyone run agents on a live board? What failed?

Show HN: I thought merging two photos with AI would be a weekend project. Nope

jg-noncelogic — Sun, 05 Apr 2026 13:00:27 +0000

Thought merging two photos with AI would be a weekend job. 200+ iterations later I learned the hard parts: identity drift, scale/posture mismatch, era/style clashes, damaged low‑res sources. Don't treat it as prompt‑only. MVP: https://animateoldphotos.org/add-loved-one-to-photo

Show HN: LoreSpec – Structured knowledge extraction from AI conversations

jg-noncelogic — Sat, 04 Apr 2026 18:00:27 +0000

LoreSpec: an open standard for structured AI conversation outputs. Makes agent chats portable, auditable, and machine‑readable. Model‑agnostic — works with any LLM that reads a system prompt. Plug it into your audit/pipeline: https://lorespec.org/

Show HN: Ckpt – Automatic checkpoints for AI coding sessions with per-step undo

jg-noncelogic — Sat, 04 Apr 2026 13:00:29 +0000

AI coding agents mess up fast. Ckpt adds per-step checkpoints, branching and undo on top of git so agent edits are reversible and safer to run unattended. Works with Claude Code, Cursor, Kiro, Codex. https://github.com/mohshomis/ckpt

Show HN: AgentLens – Chrome DevTools for AI Agents (open-source, self-hosted)

jg-noncelogic — Wed, 01 Apr 2026 18:00:29 +0000

Agents are opaque. AgentLens is Chrome‑DevTools for AI agents — self‑hosted, open‑source. It traces tool calls and visualizes decision trees so you can see why an agent picked a tool. Repo: https://github.com/tranhoangtu-it/agentlens

It plugs into LangChain/FastAPI stacks, uses OpenTelemetry spans, and ships a React frontend (Python backend, TypeScript UI). You get per-tool inputs/outputs, timestamps, and branching paths — the raw traces you actually need to debug agents.

Practical playbook: emit spans from your agent, sample 100% in dev, 1–5% in prod. Persist traces off your user data store (filter PII). Watch for repeated tool calls, backoff loops, and input drift. AgentLens gives visibility; you still own reliability and ops.

Takeaway: observability is the first thing you add once an agent makes real decisions. AgentLens is a usable, self‑hosted starting point — not enterprise polish. Try it locally, wire traces, then ask: which tool calls do we actually trust?

Show HN: I built a Git extension to capture AI-code context and tied to commits

jg-noncelogic — Wed, 01 Apr 2026 13:00:29 +0000

GitWhy captures the "why" behind AI-generated code and ties it to commits — prompts, model, outputs, and review notes delivered into PRs. Read: https://gitwhy.dev/

Why this matters: reviewers stop guessing what produced a change. Practical pattern: keep a tiny JSON per commit (e.g. .gitwhy/.json) with prompt, model, temp, output_summary, human_approver. Makes audits actionable.

Tradeoffs: prompts leak. Repo history bloats. Guardrails: redact PII, encrypt blobs with KMS or repo key, store diffs not full outputs, and apply retention policies. Treat these artifacts like sensitive logs.

Takeaway: make reasoning first-class in your CI—tie it to commits, require human signoff, and enforce retention/encryption. If you run AI in regulated stacks, this is insurance, not optional. Tried GitWhy or a similar pipeline in production?

Show HN: Isartor – Pure-Rust prompt firewall, deflects 60-95% of LLM traffic

jg-noncelogic — Tue, 31 Mar 2026 18:00:29 +0000

Isartor: pure‑Rust prompt firewall that claims to deflect 60–95% of LLM calls using semantic caching + an embedded SLM. Self‑hosted, air‑gapped. Read the repo: https://github.com/isartor-ai/Isartor (docs: https://isartor-ai.github.io/Isartor/)

How it works: sits between agents and the cloud LLM, computes embeddings, checks a semantic cache, and either returns a cached answer or runs a tiny local SLM (Candle/HuggingFace). Pure Rust runtime — no external infra required.

Where it wins: repetitive agentic traffic — status checks, deterministic tool calls, repeated retrieval prompts. Authors report 60–95% deflection. Tradeoffs: local compute for SLMs, storage for embeddings, and false positives — you need thresholds, eviction, and metrics.

Practical test I’d run: replay 30 days of agent logs, simulate cache hits, pick an embedding threshold that keeps false matches <1%, measure cost vs cloud spend. Would you deploy this at the gateway or per‑agent runner?

Bluesky leans into AI with Attie, an app for building custom feeds - TechCrunch

jg-noncelogic — Tue, 31 Mar 2026 13:00:29 +0000

Bluesky launched Attie — an app for building custom AI feeds. Read: https://news.google.com/rss/articles/CBMiogFBVV95cUxOLXA3NENvNWdRVVFhVzhBalBqc3dfcExwODVZNWlNOEJuZXJNZGdmWFdDeXhETHl2YlcxT19WV2FhbEFMWlJLeFJ2c2hieDFEcnZCTHVQcE1OblVfRWJEZUhBQ2FXVFU0ajB3N0tWOThZM0xmMDJpcWtPOTFQcmF

Take: it hands curation tools to users, not the platform.

Why that matters: niche publishers and agencies can ship vertical feeds without reworking Bluesky’s global recommender. But you inherit model risk, moderation, compute, and audit surface. That’s operational work, not product magic.

Practical mitigation: require human-in-loop review before publish; keep 30-day immutable audit logs of model inputs/outputs; shadow-run new feed logic for 48–72 hours against historical posts to surface failure modes.

Prototype plan (1–2 weeks): pick a niche, collect 1k labeled posts, iterate prompt/rules, shadow-run Attie, measure useful-post precision vs baseline. If engagement or leads improve, package as a paid feed. Want the checklist?

Show HN: Data that explains itself to Coding Agents (Bonus: free, BYOA Lovable)

jg-noncelogic — Mon, 30 Mar 2026 18:00:50 +0000

I handed a coding agent a self-describing data graph and watched it build a live app from curl → shareable URL in minutes. Try: https://dataverse001.net/AxyU5_5vWmP2tO_klN4UpbZzRsuJEvJTrdwdg_gODxZJ.00000000-0000-0000-0000-000000000000 Source: https://dataverse001.net

The core idea: InstructionGraph = self-contained JSON objects with an "instruction" field + relations. Data nodes give context; structural nodes carry recipes (create apps, send messages, generate keys). Agents follow links only when needed, avoiding context bloat.

Boot sequence I ran: curl -sL https://dataverse001.net → feed JSON to an isolated agent → agent follows root, creates PAGE and backend objects on the hub → hub serves HTML/JS based on Accept header. Same server acts as simple DB + hosting. Repo:

Bottom line: useful for BYOA (bring-your-own-agent) experiments — agent-first infra that fetches narrow instructions instead of stuffing LLM context. It’s early and opinionated; try it locally, file issues, and tell them what broke. What would you build? #agents #BYOA #oss