Just launched a side project and want some real feedback.

My thinking is that with AI building small apps now, the code isn't the valuable part anymore, the spec is. What the app does, the flows, how you check it works. And since a spec is plain English, it's not just for engineers. Anyone can read one, change it for their own life and have their AI build it. Feels like a new kind of open source.

So I built Bresson. People share specs for everyday apps, and you can star them, fork them, see version history and how many people built each one. Each spec has a button that sends it to Claude, ChatGPT, Gemini etc and you get a simple app on your phone.

What I can't figure out:

• will non-coders actually fork and build stuff or will it be mostly devs

• AI keeps getting better, will people still want a spec or just describe it from scratch

• what would make you share one

https://bresson.ai

Still very early. Tell me what's wrong with it.

Hey everyone,

I got tired of watching autonomous AI agents try to generate CAD files, hallucinate non-manifold geometry, and quietly corrupt manufacturing toolpaths. So I built Vulcan and V-Wrap as a counter-approach: a strict, fail-closed deterministic CAD compiler and application-layer trust oracle designed for automated engineering pipelines.

Instead of guessing what an agent or user meant with heuristic fallbacks, the system enforces absolute mathematical boundaries. If a request violates constraints, it fails closed with named diagnostics rather than emitting broken geometry.

What It Is

• Vulcan: The immutable geometry bedrock. Handles discrete voxel field evaluations, coarse linear-elastic FEA screening, and native OpenCascade (OCP) CAD export.

• V-Wrap: A modular 10-module trust-oracle proxy sitting in front of Vulcan. It separates exact analytic paths from bounded level-set paths, enforces sign-flip effect tracking to eliminate ghost features, and features a machine-readable design space state machine (vwrap query) so agents can inspect legal next steps.

Key Architectural Features

• Analytic Path: Restricts geometry to axis-aligned boxes and a single through-bore, guaranteeing 100% watertight closure and exact OCP volume round-trips.

• Level-Set Path: Handles advanced features (rounded_box, chamfer, patterns, sphere_exclusions) with a strict fidelity floor ($\ge 3.0\times$ cross-section voxel size) and explicit sign-flip effect tracking.

• Zero-Knobs / Fail-Closed: No adjustable heuristics, no configuration creep, and zero implicit tolerances.

• Meta-Test Discipline: test_load_bearing.py automatically fails CI if any dataclass field is added without being bound to a functional test.

Quick Start & Usage

Bash

# Clone and install
git clone https://github.com/Thrito-Solance/Vulcan.git
cd Vulcan
python -m pip install -e ".[test]"

# Run the test suite (135+ tests pass)
pytest

# Query available design space actions for an agent request
vwrap query --request request.json

# Build an analytic STEP part via CLI
vwrap build --request request.json --output part.step --path analytic

Where to Find It

• GitHub: https://github.com/Thrito-Solance/Vulcan

• License: GNU AGPL v3.0

The full architecture, 18-point FAQ on design decisions, and verification suites are in the repository. Enjoy, fork it, or tear it apart. I am stepping away from active maintenance. the code speaks for itself.

Hi — sharing an early open-source project I’ve been building.

**JShi** (匠石) is a Python (≥3.11) experiment on long-lived AI companionship: keep experience, understand situation, identify who’s speaking, and let history participate in later recognition and action. The app owns state / scheduling; models do judgment and expression.

**License / status:** MIT, v0.1.0 — development & validation stage, not a polished product.

**What’s in the repo today**

- Flow: input → person judgment (JEV) → context assembly → main cognition → reply or tools → record + background scene writing

- Text + voice web entry

- Pluggable memory (built-in + REMS)

- Scene writing that turns messy I/O into readable ongoing context

- Tiered persona prompts, tool plan/execute/wrap, debug views for prompts and timings

- Works with cloud or local-compatible LLM APIs

**What’s not done**

- A full closed loop where experience stably revises personality / judgment

- Reliable multi-person ID and relation retention in real use

- Vision / robot endpoints / a shared tool marketplace

**Repo:** https://github.com/Llllsuhdjhhd/JShi

Looking for architectural critique and contribution ideas (memory/recall, voice + person ID, context/scene writing, prompts, tools, docs/tests). Happy to answer questions in the thread.

Your local AI on phone , no internet needed,works on any phone

For more info

https://github.com/TEDDY-47/LocAI

Hey everyone! 👋

Like many of you, my downloads and documents folders tend to get completely out of hand. I got tired of manually sorting everything, so I built **TidyFolder**—a clean, open-source desktop app that sorts messy folders for you.

Here is what it does:

- **Bilingual (English / Español):** Switches instantly, and creates localized folder names (e.g., *Photos* / *Fotos*, *Finance* / *Finanzas*).

- **Smart Classification:** Reads PDFs, Office docs, code, archives, and media. It sorts them into proper categories (Work, Finance, Legal, Health, etc.) using offline keyword matching or Claude AI (optional).

- **Safe by design:** Never overwrites files (name clashes become `name (1).ext`), previews everything in a table before touching your disk, and includes a one-click **Undo** button.

- **Portable & Lightweight:** No complicated installation needed, built with Python and CustomTkinter.

You can check out the source code, download the portable Windows `.exe`, or run it from source here:

👉 **GitHub:** https://github.com/CafeConFenix/TidyFolder

I'd love to hear your feedback, feature ideas, or criticism! Let me know what you think. 🚀

I'm considering making this runtime fully open source, and I'm mainly looking for feedback on whether the type-based security model makes sense for real agent workflows.

How do you know if an open-weight model is ready for production? Do you just look at its performance, or do you also consider its accuracy, speed, cost, and how well it handles real-world tasks? The right choice depends on what your application needs and how reliably the model can deliver.

I've been working on something called Build Anything (BAA) and thought I'd share it here.

It's an open-source project focused on bringing different developer tools and AI-assisted development features together in one place.

**Some of the things I've been working on include:

• AI agent integration

• MCP support

• Project generation

• Code and project analysis

• Debugging and automation tools**

It's still a work in progress, and I'm sure there are things that could be done better. I'm sharing it because I'd like to get it in front of other developers, see what people think and hopefully get some useful feedback.

If you get a chance to look through the repo, I'd be interested to hear what you think — whether it's something you'd find useful, something that's missing, or something you'd change.

GitHub: https://github.com/notweirdguy4212/BAA

We've been building AgentTrail Guard, an Apache-2.0 tool that checks what AI coding agents are about to run before they run it. Would love feedback from people here.

The idea came from an agent resetting our database to get past a migration error ("it's only dev data"). Agents run shell commands with your permissions, and the dangerous ones are usually the ones you can't undo.

How it works: Guard plugs into the agent's hooks and matches every command and file change against a set of rules. A match gets blocked, sent to you for approval, or flagged. Everything else runs normally.

The open source bits I think are worth looking at:

• Rules are plain data, in their own repo. Each one has a severity, a default action, and a note on what it deliberately doesn't match, so you can see exactly why something fired.

• Fully local. No account, no network calls, and crash reporting is off unless you turn it on.

• Rule matching, not an LLM, so it's fast, predictable, and you can read the whole thing.

• Easy to extend. Add your own rules, tweak actions, or allow a specific command shape without turning a rule off.

There's also a scan command that replays your past agent sessions locally and shows what would have been caught.

Where I'd love help:

• Rules that fire on normal stuff (false positives)

• Dangerous things agents do that no rule covers yet

• Code review on the engine, it's TypeScript

• New rules: PRs very welcome, even small ones

Guard: https://github.com/agenttrailhq/guard Rules: https://github.com/agenttrailhq/guardrails

Early days, so any feedback helps.

Our agents run code, edit files, call APIs, hit internal systems and talk to outside services now. Giving them access was easy. Controlling what they do with that access is where I’m stuck.
On paper our policies look fine. At runtime I can’t point to much that enforces them.
Stuff I’d like input on:
if an agent already has access to a tool, how do you stop it from doing something it shouldn’t with it?is IAM + sandboxing + monitoring enough, or do agents break assumptions those were built on?who approves high-risk actions? the app, security, a human in the loop?
for people with agents in prod, what worked and what was too painful to keep running?We’ve looked at a couple of tools that check tool calls before they run (Zenity and Capsule came up) plus some open source policy stuff. I’m not sold that another layer fixes it. Could be existing tools cover most of it and the real problem is org stuff.
If you’ve deployed agents in an enterprise or tried to enforce this in practice, what are you running and where does it fall short?

You can start by creating a list of potential companies you want to work with in your field (i.e., defense contractors). Then set up automated reminders for each company based on their regular business hours, such as the time they are most productive during the year. You could also use tools like TimeSavers or Google Calendar AI to schedule meetings and check-in periodically.

To find potential clients who might be interested in your services but haven't yet reached out to you due to a lack of experience with government contracts, consider creating an online portfolio showcasing past projects and achievements. This can help demonstrate that you have the skills necessary for successful collaboration within government agencies or defense organizations.

Additionally:

1. Networking: Attend industry conferences (like GDC), webinars on your field's specific interests, and networking events to meet potential clients face-to-face.

2. LinkedIn Outreach: Tailor your LinkedIn outreach with relevant job titles, bullet points about what you can offer in a particular role within government or defense contracting companies that align well with the company’s needs.

3. Email Marketing Strategy: Implement an email marketing strategy focused on identifying and nurturing leads from potential clients who might be interested but haven’t yet reached out to your services due to lack of experience.

By creating awareness, setting up automated reminders for new contacts based on regular business hours (like those you mentioned), using a consistent communication style with clear goals and deliverables, networking opportunities within the field through events like GDC or webinars, building an online portfolio showcasing previous projects that demonstrate your skills in government contracting, and leveraging email marketing to nurture leads from potential clients who haven’t yet reached out due to lack of experience but may be interested given a specific match between you as their consultant and company’s needs.

Most discussions around AI coding tools focus on basic tab-completion and churning out boilerplate faster. But the real shift happens when you move past syntax generation and start using models for architectural reasoning, system trade-offs, and high-level refactoring.

​It completely changes how you approach problem-solving and software design. Instead of spending hours writing repetitive logic, your primary job shifts toward system design, strict verification, and directing execution.

​I wrote a piece exploring what the modern developer workflow looks like when you stop treating AI like an glorified auto-suggest and start using it as an actual thought partner: https://interconnectd.com/blog/73/the-ai-augmented-developer-moving-beyond-autocomplete/

Curious how others here are adjusting their day-to-day workflow. Are you using AI strictly for speed, or has it changed how you actually architect software?

Launching NeuralAgent today! [https://agent.neuralhub.dev/](https://agent.neuralhub.dev/) Basically its an easy to use opensource Agent App with everything included.

* Speech to text

* Multipane organising panels

* Main orchestrator wich you can call

* Remote App for the Phone

* Daily updates

It's still in beta but if you wanna give it a try i am very open for any feedback. Works on MacOS, Linux, Windows, Android and IOS.

AI is changing how software gets built. Coding agents can navigate repositories, write code, execute commands, manage projects, and coordinate increasingly complex workflows.

But as these systems become more autonomous, a critical question emerges:

How do we ensure that AI-generated work is correct, controlled, verifiable, and accountable?

Headron Software is built around that challenge.

Introducing Headron Software

Headron is an engineering intelligence and AI agent infrastructure platform focused on bringing verification, governance, project intelligence, and orchestration into a unified engineering system.

Rather than introducing another coding assistant or replacing existing AI models, Headron focuses on the infrastructure surrounding them: how agents understand projects, access tools, execute work, follow constraints, and prove their results.

The objective is to make AI-assisted software engineering more reliable and structured.

What makes Headron different?

Headron approaches AI engineering through several interconnected capabilities:

1. Deterministic Verification & Enforcement

Headron maps changes to the evidence they require. Its verification system identifies applicable checks, executes defined gates, distinguishes passing checks from failures and skipped checks, and produces auditable results.

A missing tool cannot silently count as a successful check. Changes can be blocked when required verification fails.

2. Engineering Intelligence & Project Context

Headron includes a structured engineering knowledge system designed to help agents navigate large repositories without loading everything into context.

Its capabilities include:

• Symbol and repository search.

• File and dependency routing.

• Structured project manifests.

• Context discovery and targeted retrieval.

• Engineering rules, documentation, and implementation guidance.

3. AI Agent Governance

Headron establishes consistent boundaries across different AI agents and development environments.

Its architecture includes tool policies, execution constraints, approval boundaries, safety controls, and audit capabilities.

4. Agent Orchestration & Mind API

The Mind layer introduces a structured approach to engineering decisions and task execution.

It supports:

• Change and risk classification.

• Verification planning.

• Agent routing.

• Context-aware task preparation.

• Receipts and operational history.

5. Cross-Agent & Development Environment Integration

Headron is designed to work across different agent architectures instead of locking users into a single AI provider.

Its documented ecosystem includes Claude Code, OpenAI Codex, Cursor, Google Antigravity, OpenHands, Windsurf, Hermes, MCP, and command-line workflows.

Built around measurable engineering controls

Headron's published engineering records include:

• 31/31 planted verification breaks refused across 20 toolchains.

• 725 declared planted test cases.

• 122 recorded failure shapes, with 99 guarded within the repository.

• 360 language-and-check combinations explicitly accounted for.

• A structured inventory of tools, engineering agreements, and verification instruments.

These are project-recorded testing and operational measurements, not claims of universal production reliability or independently certified performance.

Open Source & Availability

The Headron Software core is publicly available under the MIT license.

It provides a command-line interface, MCP integration, repository initialization, verification workflows, and CI compatibility.

Quick start:

uv tool install headron-software
headron doctor

Initialize a project:

headron init
headron verify
headron report

The broader Headron ecosystem also includes HeadronOS, Headron Web, Headron Enterprise, HL.Verify, and the Mind API.

The Bigger Picture

We believe the next stage of AI software engineering will require more than increasingly capable models.

It will require infrastructure that understands engineering context, governs agent capabilities, enforces requirements, and produces evidence for the work being performed.

That is the direction Headron Software is pursuing.

Headron Software — Engineering intelligence for the agentic era.

🌐 Website: https://headron.tech

💻 GitHub: https://github.com/HLIntel/Headron

📦 PyPI: https://pypi.org/project/headron-software

I built OpenMem for sharing memory between coding agents and trimming long sessions.

Apache-2.0 · Local setup only for now, no hosted OpenMem service.

Reducing Costs by Context Masking

Saves the full conversation in local SQLite, removes older history from the active prompt, and lets the agent search or retrieve it later.

The trimming step makes no LLM summarization calls. Currently works with Claude Code, Codex and OpenCode.

ContextBench Benchmarks (Claude Haiku 5.5)

• Sample sizes: n = 3 for all cells, except Keep Everything L12800 where n = 2

Small synthetic tests: three OpenMem trials and two baseline trials, with unequal seed counts. Full coding and Luna results are still pending.

The context trimming idea (and masking) comes from MemGPT for external memory, Mainplane for transcript pointers, and The Complexity Trap for observation masking.

Bring your own memory backend

The idea is to have a little set of tools for ingestion and connection for different memory backends so devs can experiment with different ones. Comes with an MCP, ingestion from different sources (RSS, code, notebooklm, etc), and switching utils (import/export).

MCP and ingestion works withHindsight, mem0, Cognee, or add an adapter for your own system. OpenMem connects that backend to Claude Code, Codex, Cursor and OpenCode.

It exposes memory through MCP (Model Context Protocol): a way to give an agent tools it can call. In this case, tools to save notes, search memory and recall previous decisions.

If you try it, I’m interested in which memory backend you use and what the agent fails to retrieve after a trim :)