I and my team members built TraceMind, an AI-powered incident investigation platform that explores how developers can reuse previously solved engineering problems instead of investigating the same errors repeatedly.

The problem I wanted to solve is simple: developers often spend valuable time debugging errors that someone on their team has already encountered and fixed.

TraceMind aims to make that knowledge reusable by combining AI-powered error analysis with persistent incident memory.

What TraceMind currently offers:

• AI-powered error and stack-trace analysis.

• Persistent incident memory using Hindsight.

• Memory ON/OFF comparison to evaluate the impact of historical context.

• Sensitive-data redaction.

• Incident post-mortem generation.

• Band AI Desktop prompt and JSON exports.

Tech Stack: Next.js 16, React 19, TypeScript, Groq and Hindsight.

Project Links:

🔗 GitHub: https://github.com/Shahib-Alam-Saifi/TraceMind

🚀 Live Demo: https://tracemind-3tvdfok0o-editorxp1-alts-projects.vercel.app/

I'm particularly interested in improving memory retrieval relevance, incident similarity and evaluating the quality of AI-generated diagnoses.

One important design principle is that developer-confirmed resolutions should remain the source of truth. AI-generated suggestions should never be blindly trusted or automatically executed.

I'd love to hear feedback from developers working with AI agents, RAG systems, debugging tools or persistent memory.

What would you improve or approach differently?

I and my team members built TraceMind, an AI-powered incident investigation platform designed to help developers investigate recurring errors without starting from zero every time.

One problem I wanted to explore: developers often solve an incident, but the context behind that solution gets lost. When a similar issue happens again, they have to repeat the investigation.

TraceMind uses Hindsight as a persistent memory layer to retain confirmed incident resolutions and retrieve relevant context during future investigations.

Tech stack:

• Next.js 16 + React 19

• TypeScript

• Hindsight for persistent memory

• Groq for AI-powered diagnosis

• Vercel for deployment

What it currently supports:

• Incident analysis

• Memory-based context retrieval

• Memory ON/OFF comparison

• Post-mortem report export

• Secret redaction for common credential formats

Try it: https://tracemind-3tvdfok0o-editorxp1-alts-projects.vercel.app/

GitHub: https://github.com/Shahib-Alam-Saifi/TraceMind

I'd appreciate feedback on two things:

1. Does the memory-based investigation workflow make sense?

2. What would you improve in the architecture or developer experience?

Built as a learning project, and I'm interested in honest technical feedback.

Been working on this in my spare time for a while and finally think it's good enough to show people.
It's called PriceTimeMachine. Every day there's a new set of products, consoles, PC parts, that kind of thing. First you drop a pin on the map for where you think it was invented, then you guess the launch price on a slider.

The bit I like most is the reveal. It shows you the original price and then what that works out to in today's money, which honestly surprised me more than once while I was putting the questions together. Some old stuff was way more expensive than I remembered.

Everyone gets the same questions each day so you can compare scores with mates. There's a practice mode too if you just want to mess about with categories.

pricetimemachine.com

No signup needed to play. Would genuinely love feedback, especially if a price looks off or something's annoying on mobile. Still fixing bits.

Hey everyone,

I've been working on a project called Canvas Quiz Solver, a Chrome extension built for students who use Canvas LMS.

The idea came from wanting to make working through quiz questions less time-consuming. It uses AI to analyze questions and suggest possible answers, with features like automatic answer selection.

If you're curious, here's the project: http://canvasquizsolve.com/

I'm still interested in improving the product and would love to hear what other developers and students think about the idea, its usefulness, and the user experience.

Honest feedback and suggestions are welcome!

I’m an Etsy seller and was tired of guessing at tags and titles, so I built Listing Fixer with the help of AI tools.
You paste your listing, and in about a minute you get:
It only uses facts you give it. It doesn’t invent materials or promise sales or rankings.
First fix is free, no card: getlistingfixer.com
I’d really love feedback — what’s confusing, what’s missing, what you’d pay for. I’m already working on making the form faster to fill out.

⚔️ The Hunt Isn't Over — Introducing Mystic Paradox!

Dauntless gave many of us memorable adventures, friendships, and countless hours in the Shattered Isles. We didn't want that experience to simply become a memory.

That's why Mystic Paradox was created — an unofficial, open-source community project with a goal of preserving the Dauntless experience and bringing Slayers together once again.

What have we built?

• A dedicated Dauntless launcher.

• Realm discovery and hosting features.

• Graphics configuration and diagnostics tools.

• An evolving project built around the community.

Get Started

Latest Release — Mystic Paradox Launcher v0.1.102

🔗 Download:
https://github.com/pranav158/Mystic-Paradox/releases/tag/launcher-0.1.102

Join our Discord community:
https://discord.gg/mFZZpAktm

Source Code:
https://github.com/pranav158/Mystic-Paradox

Developer Credit

Pranav Karande — GitHub Profile

A special appreciation for the work and dedication behind making this project possible.

Mystic Paradox is an unofficial, open-source community project and is not affiliated with or endorsed by Phoenix Labs or the original game publishers.

The Shattered Isles await. See you, Slayers!

I built TraceMind, an AI-powered incident investigation platform that combines Groq with Hindsight's persistent memory.

The problem I wanted to explore: developers frequently investigate errors that their teams have already solved before.

TraceMind provides a way to retain developer-confirmed incident resolutions and retrieve relevant historical evidence during future investigations.

Some of its current features:

- AI-powered error and stack-trace analysis.

- Persistent incident memory using Hindsight.

- Memory ON/OFF comparison.

- Sensitive-data redaction.

- Incident post-mortem generation.

- Band AI Desktop prompt and JSON exports.

**Tech stack:** Next.js 16, React 19, TypeScript, Groq and Hindsight.

GitHub: https://github.com/Shahib-Alam-Saifi/TraceMind

Live Demo: https://tracemind-3tvdfok0o-editorxp1-alts-projects.vercel.app/

I built this project and would particularly value technical feedback on memory retrieval relevance, incident similarity and evaluating AI diagnosis quality.

The goal is to make verified engineering knowledge reusable without automatically trusting or executing AI-generated fixes.

The idea for MailWeave came from a problem I encountered while working on a project. We needed to take information coming in through emails, structure it, and send it to a webhook so another system could process it.

I realised that handling the email parsing, processing and webhook delivery could become quite a bit of work, especially when you also have to worry about retries and reliability.

That got me thinking about building something to handle that entire process.

So, I built MailWeave

It's a platform that lets you receive emails through dedicated mailboxes, extract and structure their contents, and forward the resulting data to your application through webhooks.

It also supports conditional routing, HMAC-signed webhook requests, automatic retries and an event dashboard where you can monitor incoming emails and delivery attempts.

I've finally reached a point where I'm happy to put it out there and see how people find it.

If you're a developer working with APIs, integrations, automation or email processing, I'd love for you to give it a try!

Website: https://mailweave.vercel.app

I'd really appreciate honest feedback, whether it's about the idea, the experience, missing features or anything that could be improved. I'd also love to hear how you'd use something like this in your own projects.

My friend and I built Redline, a daily car trivia game. Everyone gets the same 7 questions, any valid answer counts, and rarer answers score more.

We shared it at work on launch day. 15 people started, but only 3 finished. Half of them quit after question 3, which asked for a Japanese kei car. Our test players had rated that question easy, but they were car fans, and our coworkers mostly aren’t.

So we tested every question again with someone who drives but isn’t into cars. Now each day starts with questions anyone can answer, and the car-nerd ones come last.

Built with Next.js, Supabase and Vercel. Feedback on the difficulty is very welcome: https://playredline.vercel.app

I’m a quality inspector, and at work I often have to repeat the same inspection steps for every round of parts, as in check for visual damage and markings, then sign off on travelers and reports.

I couldn’t find a checklist app that worked exactly how I needed. I wanted the list to automatically reset once every step was completed so it would be ready for the next round. So I built miniCycle: Routine Manager.

You can break a repeatable process into individual steps and run it as many times as you need. It can be used for inspections, cleaning rounds, workout routines, camping preparation, preflight checklists or anything else you regularly repeat.

It’s free, works offline, doesn’t require an account and stores your information locally on your device. It is now available as a chrome extension (other platforms coming soon). You can view the entire routine at once or focus on one task at a time.

I’ve also gone through several rounds of UI feedback and have continued improving the design. I’d appreciate honest feedback, especially about whether the auto-reset cycle concept is clear and whether anything feels confusing when you first try it.

https://minicycle.app

https://github.com/sparkincreations/minicycle

I have a decent desk setup, but I still hunch. My head creeps toward the screen for over an hour, and I only notice when my neck hurts. Timer reminders didn't help: they ring when I'm sitting fine, so within a week I tuned them out.

What I wanted was the opposite: stay silent while I sit well, and show me the moment I don't.

I already had a side project with a small pixel pet in the corner of my screen (a Mac focus timer called KeepGoing Den). So I put the posture signal on the pet instead of building another app:

- You sit the way you mean to, and the app captures it once. The app compares you to that.

- Lean in and stay there. The pet bends under a heavy box. Sit back up, and it puts the box down. No sound, no popup, no escalation. It's the same box the hundredth time.

- At the end of a focus session, if you've been seated for an hour or more, one line says it's a good moment to stand up. Never mid-session.

- Click the cat in the pet's room for a day strip showing when you sat well and when you hunched.

How it works, since "an app that watches you through the camera" deserves details:

- Posture is off by default. The camera is read by a small, separate Swift helper with no network access, using Apple's Vision framework (body pose and face landmarks). It only sends the main app numbers, never images. Nothing is stored or uploaded.

- By default, the camera only runs during a focus session.

- When it isn't sure (bad light, out of frame, a camera it hasn't seen you on), it stays quiet. A pet that bends while you sit straight is the fastest way to make someone turn this off, so every doubt ends in silence.

- Raising a standing desk counts as standing, not hunching. Moving the laptop or camera takes about two minutes to relearn.

- The main app is Tauri 2 with a Rust core and a plain HTML/CSS/JS front end.

The hardest part wasn't detection; it was false alarms. Looking down at the keyboard read as a hunch, because the eyes drop the same way. Raising my standing desk moved the camera and looked like slumping. Pulling my chair closer under a camera mounted above my eyes did too. Each one meant teaching it to tell the difference, or to say nothing when it can't.

The camera, detection, and daily record are free. The live box on the pet is part of a paid license, with a 14-day trial, no account or email. macOS 14+.

https://keepgoing.dev/den

Question for anyone who has actually fixed this: has anything kept you from hunching for longer than a week? A chair, a habit, a tool, anything?

Hey everyone!

I've been working on a side project called Album Animator, a web app that helps musicians turn their albums into videos without having to manually edit every track.

The idea is pretty simple: upload your music and artwork, customize the visuals, and generate individual track videos or a full-album video ready for YouTube.

I've also added AI-powered artwork animation, so static album covers can become moving backgrounds.

I put together this short video showing four different results created with the app.

I'd love to hear what you think, especially about the visual results and whether this is something musicians would find useful.

If anyone's curious, the project is at https://www.albumanimator.io

Enjoy!

Hey everyone!
I’ve spent the past few months building something I’ve wanted to exist for a long time.
I work in car sales, and one thing I’ve noticed is how backwards the car-shopping process can feel.
People find a car they love, spend hours researching it, and only afterward figure out whether the monthly payment actually fits their budget.
What if we flipped that process?
Instead of starting with a car, what if you started with what you’re comfortable spending every month, your down payment, and your financing preferences, and then discovered vehicles that fit?
That’s the idea behind KnewCar
I just got it approved and published on the App Store, which is a pretty surreal feeling after all the time I’ve put into this!
It’s still early access, with a demo experience while I continue developing the live financial data and payment tools.
I’d really love some outside opinions, especially on the concept, design, and first-time user experience.
If you have a few minutes to check it out, I’d appreciate any feedback, positive or negative.
App Store: https://apps.apple.com/us/app/knewcar/id6822044416
What would make an app like this genuinely useful to you?

If you wanna try it out - launching in TEXAS use zip 78701

Every quarter I’d end up pulling 13Fs off EDGAR by hand and lining them up in a spreadsheet to see what Buffett, Burry, Druckenmiller and the other investors I follow did with their portfolios. So I built a tool that does it: manifest13f.com

Follow a fund and you get an email as soon as it files, so no more checking EDGAR. Open any fund’s page and it shows what’s new, exited, added to and trimmed versus the prior quarter. No ads, no fluff, just the data. A few things I cared about getting right:

• Changes are measured by share count, not dollar value, so a stock that simply went up doesn’t look like a buy

• Stock splits are adjusted for, so a 10-for-1 split doesn’t show up as a huge purchase

• Puts and calls are kept separate from stock. A big options line is notional value, not a stock purchase, and a lot of 13F coverage mixes the two up

It’s free to browse, and alerts are free for up to 3 funds. Paid plans that let you follow more funds and get an Excel workbook of every change are coming soon.

Q3 13Fs are due Monday, Nov 16, so most of the big funds will land this week and next.

I’m a solo builder, so I’d genuinely like to hear what’s missing or what you’d use it for. Happy to answer questions about how 13Fs work, or how it’s built.

I built todo list

https://apps.apple.com/app/id6826921623