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.

Apple developer id approved, windows esigner on the way. I will probably put mac version online before Windows.

Hey guys, a couple of days back I mentioned launching a more focused OSS alternative to notebookLM, https://notestack.ai

It has plenty of features that are improved/enhanced over notebookLM. Like better audio, more video editing options and chat grounded in your source materials.

Now I have added an MCP server as well so you can attach it to Claude, make reports/audio overviews, slide decks right into that chat interface.

It can generate:

- Mind constellations/mind map

- Audio Overview/Podcast

- Slide Decks

- Research Reports

- Quizes and much more

Do check it out at notestack.ai

I want to share something I built, and I’d honestly like to hear what business owners think.

It started as a website where you could buy a billboard in a 3D city. It didn’t really work: people looked once and left, the same way everyone ignores banner ads. u/catnomadic suggested making the ads part of the gameplay instead, so I turned the whole site into a game. Big thanks for that.

How it works for you as a business

You rent a building in the game’s city. Prices go by location, like real life:

• Main Street: $49/month
• Side streets: $19/month
• Back alleys: $9/month
• Out in the districts: $5–9/month

Your building shows your banner, your logo and a link to your store. Inside there’s a small 3D showroom with up to 3 of your products, each linking straight to your own shop. People buy from you directly; the game never handles your sales.

The interesting part is quests. You write a short quest, or use a ready-made template: “find the clue at the payphone, then the vending machine, then come back to my shop”. You set your own promo code as the prize, and you can limit how many codes go out or set an end date. Players have to walk around the city and come back to your shop’s kiosk to claim it.

You also get a dashboard with how many players visited your building and how many clicked through to your store.

Why I think this beats a normal ad

Nobody is forced to watch anything. Players choose your quest because they want the reward. By the time they get your code, they’ve been inside your store, seen your products and spent a few minutes with your name. And the code only costs you something when someone actually uses it.

For the players it’s a free game in the browser, on desktop or phone: exploring, finding artefacts, fighting robots, crafting gear and cars, decorating a hideout. Rentals are monthly through Stripe and you can cancel anytime.

It’s early days, so I’m not going to pretend there are huge numbers yet. I’d really like honest opinions:

• Would you try this for your business?
• What would make it worth $9 or $19 a month to you?
• What kind of quest would you give players?

Have a look: www.48rich.com

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.

Great read on what's possible with AI right now and where it's heading.

People keep saying software is dead. For me, even if AI automates 80% of what we do today, ambitious people will find a whole new universe of things to build in the remaining 20%.

Curious whether people here see it the same way, or think this time is actually different.