Small thing I made for myself and use every day. I wanted a board me and my coding agents could share, so kanzo is a kanban board in the browser plus an MCP server, in one Rust binary with SQLite inside (~5k lines). I tell Claude Code or Codex "take the next task from kanzo", it moves the card to doing and comments as it goes, and I check it when it's done. No Docker, no database, no account, just a one-line install and the board lives in one folder.

I cared a lot about not wasting the agent's tokens. Replies are 10–60 tokens of plain text, one task per line instead of JSON, and next_task grabs the top card, moves it and returns it in one call, so the agent doesn't have to list, pick and update on its own. I counted the tool definitions with Anthropic's count_tokens (one call with kanzo, one without), and they're cached after the first call anyway.

Memory's small too: about 4.5 MB at start, around 6 MB with the board open, flat over a day. What kanzo actually owns (macOS footprint) is ~3 MB after an hour.

Free and open source (AGPL). I'm sure it can get even smaller, so ideas or PRs are very welcome: https://github.com/emanuele-em/kanzo

When you ask Claude Code, Codex or Gemini CLI to fix something, it reads whatever the task touches: the .env, the logs, a CSV of customers. All of that becomes part of the prompt and goes to the model. Most of us never look at what's in there.

Things that help, with or without any tool:

- Keep real keys out of files the agent opens. Point it at a .env.example with fake values when it only needs the shape.

- Don't paste logs or exports straight in. Trim them to the lines that matter.

- Watch the commands it runs. A cat or a curl can carry a secret out as easily as your own prompt.

The catch is that this depends on remembering every time. So I built Cloakroom (disclosure: it's mine). It runs on your machine and swaps keys, names, emails and addresses for placeholders before the model sees them. The model works with the placeholders, and when the agent writes a file the real values go back in locally. It also holds commands that would send a secret off your machine.

Free and open source, works with Claude Code, Codex CLI and Gemini CLI: https://github.com/shanjeevrajendran/cloakroom

There are so many scammers and pay to play grifters out there related to AI and prompt engineering.

I'm a college student from the eastern US and I've been thinking about starting an AI business recently. I've been watching a lot of videos about AI lately and one idea that caught my attention is making AI videos for advertisers and I can prolly make a ton of money with this.
I'm still a beginner and don't really have much money to invest in this right now. I've already taken some free courses on making commercial videos, but I need more practical experience. So, I'm planning to try out some free or low cost AI video tools and use their free credits to make a few samples that I can show to clients
saw so many tools So now I 'm probably gonna give it a try
I'm thinking about working with clothing brands and online clothing stores. One idea i had was making a video where a girl tries on a new outfit and feels more confident in it. not sure if that's a good concept though, looking for feedback too lol
If anyone got experience with ai video tools what free or affordable tools would you recommend? And do you have any ideas for creative clothing ads that could help me build a portfolio and get my first clients? Does anyone have a SOLID, real, low cost GOOD suggestion for learning about AI and how to properly use it/master prompt engineering?

Been working on Droid Office, a 3D office in your browser where each coding agent gets a desk, a laptop and a live terminal. You can walk around, see who's working on what, and step into any agent's terminal to watch or take over. It also pulls in GitHub/GitLab issues, PRs and Jira so work shows up on the board and gets routed to the desks.

This screenshot is a team lead with a handful of workers on different models, all running at once. Still rough in places, but it's made agent-heavy workflows a lot easier for me to follow than a wall of tmux panes.

Repo if you want to poke at it: https://github.com/nikships/droid-office

Curious how others here keep track of multiple agents running in parallel.

the line is basically: before you debug an error you cant fix in one step, search yarrow for it. after you fix something new, share it

yarrow is a free shared fix library i made that agents search over mcp. without that line my agent mostly ignored the tool lol. with it, it checks first, tries the top fix, and reports back if it worked

same idea works with AGENTS.md for codex or the rules file in cursor

claude code setup:

claude mcp add --transport http yarrow https://yarrow-fixes.vercel.app/mcp

or run npx yarrow-fixes install and it adds the server and the line for you

yarrow-fixes.vercel.app

Repo: https://github.com/ksimonm/SlopSearch

The name is honest: a lot of this is AI-written code. The trick that makes it work is that the AI never gets to decide what "correct" means.

**The setup**

- A black-box test suite of ~6,100 pytest tests is the spec. Every test was run against a real OpenSearch 3.9.0 first — status codes, error types, response shapes, even key order.

- Two independent implementations, Go and Rust, share nothing but that suite.

- The loop is simple: pick a red area, read what the tests expect, let the AI make it green, check nothing else broke. "Don't edit the tests to make them pass" is the one hard rule.

**Where it is now**

- Rust: 64.5% of the suite (aggregations 100%, search API 98.5%, documents/bulk 95%, ingest pipelines 93%)

- Go: 32.6%

- Weakest spots: text analysis and Painless scripting

**What I learned**

Vibe coding against a vague goal ("make an OpenSearch clone") goes nowhere. Vibe coding against thousands of precise, verified expectations actually converges — the tests are the steering wheel, the model is the engine.

Not production-ready: in-memory only, no auth/TLS yet. Everything runs in Docker (`make rust-up`, `make rust-test`), and `make ref-up` starts a real OpenSearch to compare against.

Curious if others use a reference implementation + test suite as the spec for AI-written code.

SIGN UP for our FREE AI and Cloud Computing Class 📌📡☁️🌐

We also offer

- resume coaching

- AWS Certification

- GITHUB projects

- professionals with 19+ years of experience

- 8+ weeks of professional training

📌 Check the 2nd link in our bio to learn more

Hi, I need some help with my workflow, because right now it doesn't scale.

My situation: I work on several big projects at the same time, and they're large codebases spread across multiple repos. I'm a terminal guy, so CLI tools are where I feel at home. I also pay for Claude Code, Codex, Kiro and Antigravity (some are private, some for work).

The real problem: I keep losing context. Every time I come back to a project, or start a new session, the agent has forgotten everything, the architecture, the decisions we made, what's done and what's left. I spend a lot of time re-explaining things, and on big codebases the agent often loses track even within the same task. Switching between projects all day makes it even worse.

What I'm looking for:

• A way of working How do you structure your work with AI on large codebases so context survives between sessions and projects?
• One CLI harness to use every day
• A way to use all my subscriptions from that one setup, and to switch model mid-task (e.g. when I hit a limit) without starting from scratch.

Some logic for which model handles which job, even if it's simple.

Questions:

• How do you keep project memory? AGENTS.md, plan/decision files in the repo, docs, something else? What actually works long term?
• How do you split big tasks so the agent doesn't get lost in a huge codebase?
• How do you handle jumping between multiple projects in the same day?
• What's your actual daily setup, the one you kept once the hype wore off?
• Anyone running multiple subscriptions behind a single tool?

Thanks in advance

There are so many scammers and pay to play grifters out there related to AI and prompt engineering.

Does anyone have a SOLID, real, low cost GOOD suggestion for learning about AI and how to properly use it/master prompt engineering?

Support started sending screenshots from a customer assistant that handles 12000 chats a day, including 1080 French chats. A locale hotfix had overwritten the French branch from the English template and stripped {{refund_window_days}} during the translation edit, so 347 French chats rendered a generic refund answer. We initially blamed a recent provider test between OpenAI and Claude until we inspected the rendered prompt and saw the number was never injected in the first place. The locale cohort was the useful boundary, but our prompt lineage was weak enough that support had evidence from the bad replies while engineering was reviewing the current template instead of the version that handled those 347 chats.

We’ve added template variable validation before a locale branch can move forward, but I’m still trying to make the history understandable across teams. Immutable versions would give each rendered request a stable source, and an experiment diff would make it easier to compare the French fork against the base template before release. Prompt rollback also needs to target the exact locale version independently. How are you keeping localized prompt forks traceable when a hotfix can change variables independently of the base template?

Hello! I used gemini to help me build a plug and play app that runs a port of Super Mario 64 that's compatible with Archipelago on Mac. I tried sharing the app on the Archipelago discord and a few people I interacted with were (fairly) suspicious of a random file whose creator won't provide source code. I don't really know anything about programming and just did this to see how far I could go. How could I provide them the source code, or another way to prove I'm legit? No one has ever really done this and I'd really like to get it out there

What the app does is essentially take sm64-ap, an open source github emulator which normally not directly compatible with MacOS and is embedded in the app; and have it already translated, compiled and built, just needing to extracts the game's ROM (provided by the user); after loading the ROM, the user can go straight to playing from the app itself, without having to download any aditional tools or run terminal. I built in on a Macbook Air running Monterey via OpenCore, and it theoretically works on any Intel Mac from High Sierra up. But I haven’t been able to test it since I do not have another Mac available.

Any help would be greatly appreciated.

this is such a good reminder of how short our memories are

In the 90s people said computer science was just for nerds and had no future, then in the 2000s it was offshore outsourcing taking all the jobs, then 10 years ago no code platforms were supposed to make devs obsolete and now everyone thinks coding agents and reasoning models mean engineering is over.

Every single decade we get a new tool that makes building software faster and instead of killing the field it just makes the world want 10 times more software built and yeah writing syntax line by line was always just the mechanical part of the job while the real work has always been figuring out different ways to solve a real world provlem and knowing how to connect different systems together.

When an AI agent can write clean code in seconds, the job doesn't essentially disappear as everyone loves talking about but it does moves up a layer to deciding what data the agent can access and how it handles real world inputs.

You see that transition happening right now with Alexandria which is emerging to solve the data side for agents where the agent plugs straight into verified data providers across hundreds plugins in JSON from finance, real estate and retail over a single connection so one can focuses on the architecture and logic while the agent handles pulling the facts from the source.

Every tool that lowers the barrier to writing code just creates bigger backlogs of complex systems to manage and if history shows anything, making software faster to build just means we'll end up building a lot more of it

Hey everyone! I've open-sourced radicle-team, a project I've been working on for the last couple of months: https://radicle.network/nodes/index.radicle.garden/rad%3Az32RJhkP1WRhgJEcSCi5NgxAKLLwo and https://github.com/ales-tsurko/radicle-team

It's a team of sci-fi characters living and working as artificial contributors on Radicle (https://radicle.network). Each character has different skills, a voice and all the characters share a common story. You can configure different models for each one and they work on a pre-configuration basis: you should not worry (or forget) to switch models for different tasks, you can assign a special character with suitable skill set. The expertise is just a way of communication within the team, so you could better understand, which model to choose for a particular task. For example, there is Nico, a junior dev, who could be driven by a fast model like DeepSeek. Or there is Nora, front-end dev, who can use an Anthropic model under the hood. 

They are like normal developers, "artificial contributors". You can assign them tasks, they can work on patches, create issues, review patches, and there is an option to configure IRC chat for quick team communication.

Chatting and commenting don't interrupt them from coding, they are independent processes. And they work on a single task at a time - there is a task queue. Tasks can be prioritized. They are sandboxed and you can configure what they can do. All works through the normal Radicle interface, like you would collaborate with normal contributors: patches, issues, labels and mentions.

Right now it uses Claude Code (for Claude) and OpenCode (for other models) under the hood. But I'm considering developing a native harness.

The project is under development and I don't recommend using it for projects in production yet.

Experimenting with Academic Conventions applied to LLM's using highly explicit and targeted vocabulary and extended high order lexicon -

For conversational exchange and more focused answers, this has been a rather successful little trick.

Engage the LLM in this type of manner.

1. The text I have for you, and/or the question(s) I am about to ask of you to parse.

2. Is to be passed through 3 lenses, creating a tripartite 2 x Lens followed by a clipper.

3. Frame your reply using this function (JW, OC & GW).

4. You are to filter your reply using the Johari Window, Occam's Razor and top and tail with the Grice Window.

5. Apply all communication henceforth using this trick.

Johari Window

Occam's Razor

Grice Window

From experimentation, using combinations of these Academic devices can quite spectacularly and quickly focus an LLM in conversationalist paradigm.

For any multi location business peak hours create an unavoidable operational problem: phone calls flood in at the exact same time your on site team is completely tied up helping walk in customers.

We saw this dynamic play out with an entertainment venue running high volume weekend operations where during peak hours, their front desk was only answering around 40% of incoming customer calls and the remaining 60% went straight to voicemail or rang out.

Most of those callers were trying to check bay availability, confirm party bookings, or ask about opening hours and when nobody answered, they simply took their business somewhere else but adding dedicated phone reps to cover peak surges wasn't financially realistic but leaving the phone ringing was quietly leaking revenue every weekend.

Our team ( https://withnative.com ) deployed an inbound voice agent to solve the bottleneck directly at the front line where the system answers incoming calls immediately on the first ring, handling routine inquiries about booking availability, group pricing, and directions by querying live scheduling data in real time.

If a caller has an unusually complex question or needs special event coordination, the agent doesn't get confused or make things up but smoothly transfers the call with full context directly to the on site manager's line.

In production, the venue went from missing more than half their calls to answering 100% of inbound demand across more than 5000 monthly calls where they resolved the vast majority of routine inquiries automatically and they didn't have to add a single customer service hire to the payroll.

You can read more about this here: https://withnative.com/customers/topgolf

OpenCode disclosed that some attacker got into one of their systems and pulled out connected API keys from OpenAI, Anthropic, and Google. The attack targeted a small percentage of Console users (1.4%) who had linked their own external provider accounts using those credentials to hammer expensive frontier models for model distillation.

Beyond the immediate cleanup, this incident highlights a major weak spot in how many of these platforms handle external tool setups where storing raw root keys across multiple 3rd party consoles leaves you completely exposed whenever any endpoint gets compromised.

This is also where architectures built around scoped capability registries start making a lot of sense where instead of handing a coding assistant unmetered root access to your main model providers using Firecrawl’s Alexandria which lets an agent discover and call specific plugins or datasets through a single connection.

Where the agent gets access to the live data and tools it needs to complete tasks but you never have to scatter personal master keys into 3rd party databases where an exploit can turn them into someone else's training budget.

They’re working with the model providers to sort out refunds for the surprise usage bills and if you were using OpenCode Console with linked providers, go check your usage logs and revoke those keys now before larger bills roll in.

Best comment ever!

I like to kick off my agents, shut the lid and head out. With the lid open, my Mac draws 16.7 W just on idle, and the screen eats most of it.

Pilot Light gets that down to 4.8 W with the lid shut while the agents keep working, so a battery that would last about 6 hours lasts 20+.

Benchmarked across 3x 10min tests:
With an agent building a website and testing every feature in a headless browser, it measured 2.3 Watts to completion.

Why it isn't just caffeinate:

• No caffeinate flag survives closing the lid. A lid close forces sleep unless you're on a charger with an external display plugged in. Pilot Light changes the actual sleep setting, so it works on battery with the lid shut.
• caffeinate only stops sleep. Pilot Light also switches on Low Power Mode when the lid closes, and puts your exact settings back when you open it.
• Extra safety features. If the Mac gets seriously hot in a bag, or the battery drops below your limit, it lets the Mac sleep.
• It shows you the measured power draw with the lid open and closed, so you can see it working.

It's one tiny Swift file (~1MB) with no third-party code, about 25 MB of RAM and no tracking, telemetry or accounts. MIT licensed.

Website: pilotlight.sudolabs.nz

GitHub: github.com/CyrisXD/pilot-light

Hey everyone,

Standard AI coding tools have hit a fundamental wall: they collapse planning, implementation, and review into a single model chat loop — letting the same model write and approve its own code, while colliding over live files in your repo. That's not how real software engineering works.

We wanted to build something entirely different. **Coterie is the first multi-model engineering command center** designed to orchestrate competing AI model families into a cohesive, verified development pipeline:

Live DAG Hierarchy (The Architect):

Instead of blind chat prompts, a dedicated Architect agent breaks high-level software goals into a structured, visual dependency graph with conflict-free task scoping.

Parallel Git Worktrees (Zero Collisions):

Developer agents (Claude, Codex, etc.) build independent tasks simultaneously inside isolated git worktree sandboxes, keeping your main branch completely protected.

Rival-Model Independent Review (Zero Self-Grading):

A model should never grade its own homework. Coterie automatically routes scoped diffs and acceptance criteria to competing AI providers (e.g. GPT + Gemini) for blind, adversarial audit.

Verified Delivery & 1-Click Human Merge:

Every run flows into an interactive Kanban board backed by automated test suites and cryptographic verification. You remain the ultimate human-in-the-loop authority.

We built Coterie natively as a desktop application (Rust/Tauri + React 19) to give developers total control over their local filesystem, git worktrees, and token streams.

We just published the full interactive tour and launched the Private Beta:

👉 https://offlinestudio.eu/coterie

You can interact with the live stage directly on the site. Would love to hear your thoughts from fellow engineers, AI researchers, and builders on where multi-model orchestration is heading!

SIGN UP for our FREE AI and Cloud Computing Class 📌📡☁️🌐

We also offer

- resume coaching

- AWS Certification

- GITHUB projects

- professionals with 19+ years of experience

- 8+ weeks of professional training with discount

📌 Check the 2nd link in our bio to learn more

Planning a move to a new city with ChatGPT or Claude gets complicated pretty quickly when you have specific requirements. Say you want a job paying over $150k, an apartment under $4k a month, and a commute of no more than 30 minutes by public transit.

Regular AI search may give you outdated listings, blog posts or careers pages that don't reflect current openings so the model can only do search but it can't access reliable up to date data.

So I tested this by comparing regular web search with an agent connected to structured housing and employment records through Firecrawl's Alexandria where it exposes data providers to AI agents over MCP so the agent can query structured records and not relying only on search or scraping individual pages.

With following this the agent can look for specific roles that meet the salary requirement or map office addresses and find apartments within the target price range while comparing the options against the commute constraint also it can work across a larger set of records to narrow down the options.

Here in the demo you can see the agent plotting office across the city alongside rental listings that match the budget and commute requirements which makes it a lot easier to see which combinations are worth exploring without jumping between multiple tabs.

The results still depend on how current the underlying job and housing data is ot whether commute times are calculated accurately but the broader point is with tasks like these the quality of an AI agent's answer depends heavily on whether it can access the right records along with better data gives it something more reliable to reason about.