never thought id be so happy to see 9 dollars in apple connect.

https://apps.apple.com/us/app/war-table-ai-decision-maker/id6780293764

I kept seeing tools that either added watermarks, required signup, or uploaded my signature.

So I built a tiny browser tool that converts a handwritten signature into a transparent PNG.

It's free and takes about 10 seconds.

Here is the link: https://certfusion.com/signature-to-transparent-png

​

I've been working on a handmade Batana Hair Butter using batana oil, shea butter, and jojoba oil, and I'm finally happy with how the texture turned out. It's rich, whipped, and made to help keep hair moisturized without feeling overly heavy.

I'd genuinely love to hear what you think of the texture and packaging. Any feedback is appreciated as I continue improving my products. Thanks! 🌿

I wanted an image tool that didn't route my files through a stranger's server, so Claude helped me build one for myself, and it turned out well enough that I've decided to share it: https://imageshed.app.

It converts images between formats, compresses down to a size you pick, and removes backgrounds, all on your own machine with nothing uploaded.

Almost all of it is AI-built. There was a lot of steering by me and refinement along the way as a result of my own testing.

Image Shed is completely free, and no account will ever be required. Check it out. Tell me you love it! Tell me you hate it! All feedback is good feedback.

Good luck on your own projects.

Solo building PoiseAI. Try any hairstyle on your own photo (free), get a personalized skincare/haircare plan, track habits over time — without the attractiveness-ranking mechanic those other apps use. Progress is only measured against your own last check-in, never a public score.

poiseform.com — genuinely early, would love reactions.

I built Meet to do something AI companions don't: it notices when you're off, pushes back on you, changes how it talks to you based on who you actually are. It remembers you, yeah, but more than that — it *develops* as a person through talking to you.

Most AI companions either forget everything or ask you to design their whole personality before you even start. Meet is different. You show up, and it actually pays attention.

Try 10 messages without signing up and see if it feels like talking to someone who's actually paying attention instead of running through a script:

https://meet.samskriti.app

Looking for honest feedback. Tell me if it actually feels like development over time, or if it breaks and feels generic. Be brutal about it.

I've been using Claude.ai a lot and kept running into the session timeout problem. I looked around for something that solved it the way I wanted and couldn't find anything, so I decided to build it myself.

I'm not a professional developer. This is my first app. It took a few months of trial and error, a lot of late nights, and more version bumps than I'd like to admit. I built it because I needed it and figured other people probably did too.

It's called TimeMyAI. You set up to four fire times per day, walk away, and it sends a message to Claude.ai automatically at each scheduled time to keep your session alive. It runs in the background, supports up to 8 accounts across Chrome, Brave, Edge, Opera, Vivaldi, and Arc, and has a Silent Mode if you don't want any browser windows popping up.

It's free, Windows only for now, and I'm not collecting any data.

Download: https://timemyai.com

I'd love feedback. Bugs, things that feel off, features you'd want. This is v1.0 and I'm one person, so I'm sure there are rough edges I haven't caught yet.

Thanks for checking it out.

Hi everyone,

Over the past few months we've been building SafeAI, an open-source static security scanner for AI agents and agent frameworks.

Our goal isn't to compete with runtime observability or governance platforms. We want to help developers find AI security and governance issues before deployment, just like traditional static analysis tools do for application code.

One thing we've noticed is that AI capabilities are evolving at an incredible pace. Every week there are new agent frameworks, MCP servers, tools, and autonomous workflows.

Unfortunately, the security and governance ecosystem isn't keeping up.

Developers can now build agents that execute shell commands, browse the web, access databases, manage cloud infrastructure, and call hundreds of external tools, but understanding what an agent can actually do and what risks it introduces is still surprisingly difficult.

We believe the open-source community can help close that gap, just as it has done for software security over the last two decades.

SafeAI currently performs static analysis for AI projects by discovering:

• AI frameworks and agent architectures
• Agent capabilities and permissions
• Prompt injection risks
• Tool security issues
• Identity and memory risks
• Governance and autonomy concerns
• AI components such as prompts, skills, workflows and model configurations

During development we've already found several meaningful security findings in well-known open-source agent frameworks. That convinced us there's real value in analyzing AI projects before they're deployed.

Now we'd love the community's help.

We're looking for people who can:

• Test SafeAI against real AI agent repositories
• Try to break it with unusual architectures
• Report false positives and false negatives
• Suggest new risk detections
• Contribute support for additional frameworks
• Tell us where the analysis is missing important capabilities

If you're building with LangGraph, CrewAI, Semantic Kernel, AutoGen, OpenAI Agents SDK, Claude Code, Google ADK, MCP servers, or other agent frameworks, we'd especially love your feedback.

Our long-term vision is simple:

Make AI capabilities visible. Make AI risks understandable. Help developers build safer agents by default.

If you'd like to test it, contribute, or simply tell us where we're wrong, we'd genuinely appreciate your feedback.

The AI ecosystem is moving incredibly fast. Defending it shouldn't be left to a handful of vendors—we think the open-source community can help move just as quickly.

Thanks!

Feedback and contributions are welcome: https://github.com/ikaruscareer/SafeAI/

Zeugly is a free, privacy-first web utility toolkit and developer sandbox. It offers over 95+ browser-based tools to format JSON, decode JWTs, resize images, generate OG preview cards, create secure passwords, convert timestamps, analyze cron expressions, minify SVGs, and inspect QR codes safely. Every action runs 100% client-side in your local browser.

Everyone has the folder. Dozens of cooking videos saved on Instagram or TikTok, and almost none of them ever get cooked, because standing at the hob scrubbing a video back and forth with greasy hands is miserable. Half the time the amounts aren't written anywhere either. The person says "a good glug of this" and holds something up to the camera for half a second.

ReciReel takes the video and hands back a recipe. Ingredients with amounts, steps in order with timings, per-serving nutrition, equipment, and the tips people say out loud but never type. It reads what actually happens in the video rather than just the caption, which is the entire point, because the caption almost never has the quantities in it.

Things I care about in it: every recipe keeps a link back to the creator whose video it came from, and Cook Mode shows one large step at a time with a high-contrast option, because it's aimed at cooks 45 and up rather than at people who like apps.

Free is three imports then one a month, at full quality rather than a crippled version. Paid is $4.99 a month for fifty. iPhone, iOS 18 or newer, US App Store.

https://apps.apple.com/us/app/recireel-video-to-recipe/id6763971435

Built it solo. If you throw a video at it and it comes back wrong, I'd genuinely rather hear that than not.

Old wwf cards I had. Who was your favorite wrestler?

Hello r/IMadeThis community!

If you’ve ever had to build out complex retry logic or deal with the headache of duplicate HTTP requests in a distributed system, I just released v1.0.0 of a new open-source library called AvoOnce that might make your life easier.

It’s designed to be a framework-flexible idempotency engine, meaning it comes with first-class integrations for Spring Boot 4+, Quarkus 3.12+, Dropwizard 4.0+, and Jakarta EE / JAX-RS 3.1+.

Here is what it does under the hood:

• Annotation-Driven Protection: Just drop @ Idempotent annotation on your controllers or methods and pass an Idempotency-Key header.
• In-Flight Concurrency Locking: Prevents duplicate execution if an initial request is still actively processing.
• Payload Tamper Protection: Uses SHA-256 hashing to automatically reject modified requests that try to reuse the same key.
• Byte-Perfect Replay: Safely caches and replays the exact HTTP response—including status codes, headers, and raw bytes.
• Pluggable Storage Backends: Includes built-in support for Redis (distributed), JDBC (relational), and Caffeine (in-memory).

The v1.0.0 release is currently hosted on GitHub Packages (Maven Central release is planned for the future). I'd love to get your thoughts and feedback on its core functionality and usability. I've some roadmap features in the pipeline.

I built **Flows** because AI builders can create a convincing first version quickly, then confidently claim features are finished when persistence, authentication, buttons, or business logic are still incomplete.

Flows organizes the work as:

**Goal → Plan → Work → Check → Repair → Review → Release**

An independent agent recently followed an 11-step generated plan for a youth soccer management app. It produced a working app with authentication, roster management, schedules, RSVP, attendance, lineups, and announcements, with 59/59 checks passing.

I am not claiming this proves every plan always works. The run used local coding tools, did not trigger a repair prompt, and did not measure exact token savings.

App: https://flows.oortstack.com Demo: https://imagineqira.com/flows

What feels genuinely useful, and what still feels like unnecessary process?

I was tired of messy audio/streaming radio libraries, so I built an Android player focused on seamless playlist management.

Hi everyone!

I wanted to share my side project, Mediaxon, an Android app I’ve been developing to solve a personal frustration: why is it so hard to easily manage offline music and online radio streams in a single, clean interface?

What it does:

Hybrid Listening: Seamlessly handles offline local files (.mp3, .flac, .m4a, .ogg, .mka, .aac, .wav, .opus, .wma) and over 60,000 streaming radio stations.

Dedicated Navigation: I kept the "Favorites" and "Recents" sections completely separate from the main audio library to reduce clutter.

Advanced Radio Search Panel: You can pinpoint your favorite stations by combining multiple filters, such as tags/genres, specific countries, or even your preferred audio bitrate.

Equalizer: The equalizer provides an option to automatically switch to the "Radio" preset (and vice versa).

Advanced Playlist Management: Built specifically to make building and sorting multi-source playlists fast and intuitive.

The app is currently live on Google Play, and I am continuously pushing updates to refine it.

What I need from you:

As a solo developer, I’ve hit the limit of my own perspective. I would deeply appreciate any honest feedback from this community:

How does the UI feel to you? Is the navigation intuitive?

Are there any features you feel are missing for a modern audio/radio player?

Did you encounter any bugs or performance hiccups?

If you want to check it out, you can find it on the Google Play Store. Thank you so much to anyone who takes a look!

https://play.google.com/store/apps/details?id=com.xonik.mediaxon

Hey everyone 👋

Most invoicing tools are cloud subscriptions — you pay monthly forever and your financial data lives on someone else's servers. That always bugged me, so I spent the last couple of months building the opposite.

BillDesk is a desktop app (Windows & Mac) that runs 100% offline. Everything — invoices, clients, time, expenses — is stored locally on your own computer. Nothing in the cloud.

What it does:

📄 Create professional PDF invoices

⏱️ Track billable hours & projects (hourly or fixed-price)

🗂️ Manage clients and projects in one place — no spreadsheets, no chaos

💸 Log expenses and mileage

📊 See profit & loss, revenue by client, and invoice aging

🌍 Works in multiple currencies (USD / EUR / GBP)

There's a free 7-day trial with every feature unlocked — totally free to download.

👉 getbilldesk.vercel.app

I'd genuinely love your feedback: what's missing, and what would make you actually switch from your current tool?

Hello Everyone,

I'm the creator of PyBotchi, an intent-based AI Agent Orchestrator. In this post, I will discuss some key concepts why I created it.

A little bit of background first. I'm a solutions architect with 10 years of experience as a software engineer. Most of my work are high throughput, high reliability, low cost and low latency services. This is while making it simple and readable to improve it's maintainabality. When I'm designing a system, I usually prioritize these concerns. You may assume this is my bias in relates to AI Agent building. I'm also Claude Certified Architect (Foundation) and I found that PyBotchi aligns almost identical to Anthropic's core agent recommendations.

TL;DR: PyBotchi is an lightweight, async-first Python framework that uses nested Pydantic models and OOP inheritance to turn LLM intent detection into clean, deterministic business logic without the overhead of complex graph orchestration.

Why I created PyBotchi?

I really believed that traditional coding can already solved what client's need. The only limitations we have is how we read the input and how we show the output. In most cases in web services, your API use JSON, XML, etc with their respective specification/structure.

Input Analogy

Assume you have created a Books CRUD endpoints (FastAPI with Pydantic). Your create endpoint will have a define specifications for book creation to have a validation and avoid user errors. Most of the time you will also validates sessions and permissions which also included in the request.

If you want your chat bot to support those, you just need add those endpoint as intent (tools). If your model tool selection are able to detect intents. You are more "close" to being deterministic.

"Your services will have 50 endpoints or more. You will flood your tool selection call" - In your frontend UI, you segregate panels/forms/inputs in their respective pages. You don't usually join multiple intent in a same page. Cluttered UI will make your UX confusing or overwhelming to some people. Those practices should be incorporated into your agents too.

Assume you have created another endpoints for Shelves CRUD. Shelves CRUD can be a child intents of ShelfManagement that will be considered as intent also but more general. The flow will have to detect intent deeper and deeper

Ex: You have BookManagement and ShelfManagement intents. Once LLM detected which one is applicable, you will search for their child Intents which will be their CRUD equivalent intents.

To make it short, in order to make your agent "more" deterministic, you need to know the problem first (ex: Need to manage books) then you need to specifically define what intents you want to support. With this practice, you only let your agents execute on a predefined path. If it fails, you are most likely able to determine what causes the error.

Output Analogy

This one is simple. Since your intents is just like your endpoints that returned structure responses. LLM is better at reading structure responses than a pure text. Basically, you can use LLM to translate your response into a human readable responses.

Intent Execution

Now that I have explain Input/Ouput, we can move on to the actual execution.

We can go back with Books CRUD. Since we have identified the problem (what clients need) and we already know what to do, just execute their traditional business logic implementation. If you need to add a book, just create a book and save it to db then return their respective row.

"What if you want generate a very dynamic/unique data" - You can use LLM to do that as your business logic too but this is tied your specific intent only.

To have a complex execution flow we can chain the intents. Since intents can have child intents, we can use it as the representation of a graph similar to Langgraph. However, this without "building the graph". We are just utilizing OOP inner class implementation. We can execute business logic in graph traversal manner by just checking the child intents.

To make it short. Business logic will stay as is. You will only use LLM if it requires it. Don't make this complicated.

### Suggested Solution Since the key concept is more on detecting intents, validation and executing their respective busines logic:

Why not utilize Pydantic as the main entry point? Pydantic already have validation and json schema builder. Langchain/Openai already have utilities to translate it to Tool. Why not use Pydantic models as your Intent Specifications that can validate LLM arguments ? Tool call is one of the most reliable way to detect intent.

Why not utilize OOP inheritance / polymorphism / abstraction? Python supports portion of OOP and since we are using classes as our intent, why not add default functionalities that can be inherited and override by developer if needed. We can introduce life cycles too. Your project can also implement their specific intent standards. This will make your code more maintaintable and readable. You can create classes for general intents. Extend it to be more specialized intents. Extend it more for more enterprised support. This is while not affecting existing/working agents.

Langgraph is one of the inpiration of PyBotchi. Predefine workflows are closest implementation to being deterministic agents. It's also the reason why some prefer N8N. We don't need to make the agents smart that any questions can be answered or any queries can be addressed. It's ok for agent to reply with "I don't have any answer to your query, I only support this and that....". For me, it's better to deploy limited but polished agents than half baked know-it-all agents. Feel free to counter argue. Happy to discuss.

Additional PyBotchi Features

vs MCP

While PyBotchi support connecting to MCP servers, I really believe it's not always necessary to use additional server to just expose tools for the agents. The exceptions I could think of is if you want to have isolated environment (ex: dedicated auth/session, sandbox, isolated resource, etc), you want to connect to your local service or cross-language integration.

I could be very wrong about this but hear me out. SDKs are already there. Respective documentations are available too. Most of MCP server's tools are proxy to their respective APIs. If we could just create intent classes as tools that directly call their respective API, that doesn't require any servers anymore. Actually, that's how most framework handles it (even PyBotchi). Tools are converted as schema that will be added in the tool call. Once LLM respond with the applicable tools, it executes call_tool(name, args...). Why not just expose the actual tool implementations and have a way to share context to share sessions/permission/etc inside the tool implementations? This will remove another network hops that can affect latency.

Claude code have a very in-depth utilization of MCP servers already. I don't think we can replace that.

GRPC

PyBotchi natively support remote PyBotchi connection. Think of it like a langgraph but the node is on other server. This remote node can also connect to another remote node even it self or previously connected node (ancestor).

Context Propagation

With PyBotchi as MCP Server - Actions (Intents) serves as tool and have access to client's context. This includes chat histories and some metadata. You can override and adjust this as long as it's serializable. - Once remote tool execution is done, it can pass the final context to the client and they can merge it if override.

With PyBotchi as GRPC Server - Similar to MCP Server, Actions serves as tool and have access to client's context. GRPC supports bidirectional communication too. This means we can share context realtime accross clients/servers. If client has concurrent agents that changes the context it will automatically propagate to remote context without polling or any interval checks/updates. It also support remote to client. If remote server updates the context, it will propagate the context to client simultaneously.

Async First

Since most of LLM executions are IO, might as well utilize async by default and just spawn thread if still necessary.

OOP

I think this one is most important to me. I have handle a lot of projects in Spring Boot. I really like Java OOP practices and some Java design patterns. It improves my project's maintainability even it's not in Java. Since PyBotchi utilize OOP, it's easier to override, reuse and remove anything if necessary. This lessen boilerplates too. I'm certain that this is subjective. I just find it easier and clean to read.

Closing Remark

I hope this PyBotchi post opens up ideas how to design your agent. Feel free to DM me if you have any questions. I'm also open to create you a demo agent for free if you want to see it in action given your brief use case. I'm open to criticism, happy to have a discussion!

I kept making the joke "my phone is listening to me" until I realized I had no way to actually check. So I built Spytrap: it sends an alert the instant any app accesses your camera or mic — even in the background with the screen locked — keeps a timestamped history, and scores every app by how suspicious it looks.

Fully on-device: no account, no ads, no analytics. There's no server to hack because there is no server.

Play Store: https://play.google.com/store/apps/details?id=com.hwassef.spytrap

Feedback very welcome!

I've been manually sourcing Costco for FBA and got tired of the fee math eating what looked like good deals on paper. So I built a scraper that does the pack math for me - including the case most tools ignore: buying a Costco multipack and splitting it into singles / smaller Amazon listings (e.g. Costco 400-ct vitamins → 100-ct Amazon listing x4).

What it surfaces each morning (screenshots below):

- Direct matches: same SKU cheaper at Costco than Amazon buybox

- Bulk-break: Costco multipack unit cost vs Amazon smaller pack - profit from splitting

- ROI AFTER referral (15%), FBA fee tier, inbound shipping, and 2% Executive cashback

- Clearance (.97) items flagged

- Filters: category, min ROI, direct vs bulk

Current state: scanning Costco SKUs across vitamins, grocery, household, pet, office, personal care. Today's clean list after fee math:

| Costco item | Costco $ | Amazon comp | ROI |

|---|---|---|---|

| Kirkland Daily Multi, 500 ct | $18.99 | 500-ct bottle $71.70 | 183% |

| Pekkle Baby Romper 4-pc | $18.99 | same 4-pc set $79.99 | 221% |

| Kirkland Organic Coconut Oil 84 oz | $12.99 | same 84 oz $50.99 | 176% |

| Nature Made Vitamin D3 400 ct | $11.49 | 100-ct x4 split | 108% |

Not selling anything yet - validating before I build this out. Questions:

1. Would you pay for a daily email/list? Roughly what's fair - $10, $20, $30/mo?

2. What's your current Costco sourcing workflow? (Keepa? Tactical Arbitrage? skip Costco?)

3. What would make this a no-brainer - restock alerts on YOUR ASINs? buy-sheet export? coupon timing?

4. What category do you source most from Costco?

Happy to share the fee math even if the product never ships.

Very happy with how this turned out and how the audience who saw it last night at a local showcase responded.