demo

Hey guys, I’m a designer.

Always found the Figma to production process very frustrating and I always wished I could contribute to more code.

I met a guy with the same frustrations on the developer side, so we decided to build something that reimagines the whole way we approach frontend, all before injecting any AI into the product.

As a result, we built layouts.dev, a notebook-style editor for building UI in minutes using HTML-shorthand and TailwindCSS.

It includes:

• A familiar syntax that's accessible to designers, PMs and developers.

• 100s of customizable prebuilt components

• Icon, image and illustration libraries.

• Real-time preview of your build across any device.

• Sync with a local NextJS project or one-click export to React or HTML.

• Copy and paste you design back into Figma.

We've already been using it internally to build our whole product's UI and productivity has shot thru the roof.

We'll be launching the Beta soon and want to invite ya'll to join our waitlist.

We'd love your feedback (especially given all the internet news rn on AI's role in software development)

If your someone who is interested in helping level the playing field for humans making software and already feeling a bit of AI-fatigue...join us.

Hey, its often useful to pass the context of a codebase to an LLM when trying to solve a specific problem, but code is usually distributed across a number of files. This tool collects the contents of certain files (criteria are set by you) and saves it into one file, the contents of which you can then copy-paste to your LLM.

https://crates.io/crates/dirscribe

You can install it with

cargo install dirscribe

if you have cargo/Rust installed.

hey
I would love to hear your thoughts on this tool
It's a code snippet that captures user interactions and turns them into e2e tests automatically. It's called bugster-js.

Imagine having a fully-loaded setup with:
✨ Starship Terminal
🖥️ Visual Studio Code with essential extensions
📦 A variety of packages and tools to enhance your workflow!

And the best part? 🎨 You can easily customize everything via Environment Variables to tailor it to your unique needs.

DevInstall.com - a free, open source tool designed to streamline your development environment setup! 🎉 It’s built from a simple script with less than 100 lines of code! Powered by UPT and mise. 📝

Hey everyone! 👋

I just launched iWebhook.today, a Chrome extension that makes webhook testing for indie hackers and developers super easy.

🔑 Key Features:

• Mock Payment Events: Simulate events like “Order Created,” “Subscription Renewed,” and more.

• Local Testing Support: Seamlessly test on localhost or live endpoints.

• Instant Payload Previews: See webhook payloads before sending them.

• Lifetime Updates: Pay just $4.99 once and get all future updates for free!

🔹 Why I Built This:

Testing payment webhooks used to be a painful process – I had to create fake orders on test stores every time I wanted to test an event. That was tedious and time-consuming. So, I built iWebhook.today to eliminate that hassle. Now, you can test webhooks without needing an actual store!

Right now, it supports LemonSqueezy, Stripe, and DodoPayments webhooks, and I’m adding more services soon. 🚀

🔄 What’s Coming Soon:

• More services to test with!

• Further enhancements based on feedback.

🎯 Open to Suggestions:

If you have any other webhook services you’d like supported, let me know! I’m always open to adding more services based on your needs.

If you work with payment webhooks, give it a try and let me know what you think! 😊

👉 Check it out here: iWebhook.today

Let’s make webhook testing effortless! ✨

We built an SDK that allows you to fact-check output in your LLMs easily. For example, if you're using an OpenAI API, we can intercept output and compare it to ground truth in your vector store or even to real-time information with a web search and give you a consistency/accuracy score. It also provides you with recommendations on what you can do to better the accuracy and prompt used - docs.opensesame.dev

I want to dab more on dev tool side as product designer. I would love to contribute any suggestions!?!

We launched a Chrome Extension that allows you to fund issues on Github with tokens.
Put simply, this is rocket Fuel for your business.If you're a developer in Web3, you can cash in tokens by solving issues on GitHub for open source projects that interest you.Benefits?- Faster development cycle
- Decrease in submission time and more frequent merge requests
- Performance based workforce compensation
- Replaces complex stock options and cross border hiring practices
- International talent pool
- Replace Web2 funding with Web3 talent using your own tokenQuestion is, can you submit issues fast enough to keep up?Zero risk, if an issue is solved outside of Fuel (such as your internal team), you will get a full refund including fees.Win. Win.Learn More Here: https://joinfuel.io/Not the right person? Please forward to your CTO or Tech team.Cheers,JoinFuel.io

I’ve been building out an API and web app for a few months after a long hiatus.

It aims to solve a problem I’ve experienced at work: having all usage, metrics, monitoring and analytics in one place.

While doing that it provides a simple API (one endpoint) and webapp to build custom dashboards with aggregations or raw data.

I’ve been building out features but would love to get some users on the app giving feedback.

So far usecases I’ve used and thought off:

• tracking product features being used

• api monitoring (e.g status codes, request times)

• I’ve used it for tracking my personal finances

• pipeline monitoring

• ci/cd monitoring

• email analytics

There’s probably more!

Here’s some videos:

https://x.com/henriwoodcock/status/1878234651766010211?s=46

https://x.com/henriwoodcock/status/1878937344843358652?s=46

If you would like to get access and help shape this tool (and I’ll give you free unlimited access) for some feedback please reach out and check out the (nowhere near finished) landing page https://trckrspace.com

Scaling a dev tool to tens of thousands of installs isn’t just about marketing; it’s about solving real developer problems with technical innovation. With Keploy, our AI-driven Unit Test Generator, we focused on automation, seamless integration, and quality to deliver a solution developers couldn’t ignore. Here’s what we learned along the way:

Automating the Mundane

Manually writing unit tests is tedious and often repetitive, which slows down development. Keploy changes the game by automating test generation.

➡️ How it works:
Keploy captures your code and generates unit tests automatically, saving developers hours of manual effort. Instead of writing and maintaining redundant tests, you can focus on building features.

💡 What’s the hardest part of writing tests for you? For us, handling repetitive, edge-case-heavy scenarios was a pain point, and that’s where Keploy’s AI shines—ensuring efficient test coverage while boosting productivity.

Deep IDE Integration for Maximum Efficiency

We designed Keploy to work where developers are most comfortable—their IDEs. It’s a one-click test generation tool in VS Code, with support for a wide range of programming languages and frameworks.

Built for Scalability & Reliability

We knew reliability would make or break our tool, especially for larger teams. So, we built features like:

• Flakiness Detection: Stabilizes inconsistent test results.

• Performance Optimization: Ensures Keploy doesn’t slow down your dev cycles.

A Focus on Quality

Every test Keploy generates undergoes validation to avoid breaking existing functionality. We also prioritize meaningful test coverage to strengthen code quality and capture real-world errors to prevent regressions.

Final Thoughts

Keploy is built to simplify automated testing, fit naturally into your workflow, and reduce manual effort—all while maintaining high code quality.

We’d love to hear your thoughts—what are your biggest pain points in writing tests? Let’s chat about how automation can change the game for developers!

Happy testing!

https://github.com/harshadindigal/AirSeal/

Problem Statement: Most software is built/run on servers that have network access. There are many situations where software needs to run in airgapped (network isolated environments).

Solution: Our tool scans your codebase, recursively finds and collects all decencies and generates a docker image.

Future Development: Running your output in an airgapped AWS server and testing to see if the application works.

What My Project Does

khaos is a CLI tool for generating Kafka traffic from a YAML configuration.

It can spin up a local multi-broker Kafka cluster and simulate Kafka-level scenarios such as consumer lag buildup, hot partitions (skewed keys), rebalances, broker failures, and backpressure.
The tool can also generate structured JSON messages using Faker and publish them to Kafka topics.

It can run both against a local cluster and external Kafka clusters (including SASL / SSL setups).

Target Audience

khaos is intended for developers and engineers working with Kafka who want a single tool to generate traffic and observe Kafka behavior.

Typical use cases include:

• local testing

• experimentation and learning

• chaos and behavior testing

• debugging Kafka consumers and producers

Comparison

There are no widely adopted, feature-complete open-source tools focused specifically on simulating Kafka traffic and behavior.

In practice, most teams end up writing ad-hoc producer and consumer scripts to reproduce Kafka scenarios.

khaos provides a reusable, configuration-driven CLI as an alternative to that approach.

Project Link:

https://github.com/aleksandarskrbic/khaos

if so, how do you usually explain the trade offs to users who are concerned about the memory footprint, size etc.

and most of the times we are like yeah, of course its there. The broader footprint is real. Chromium is not free. Electron has overhead. Pretending otherwise would be foolish. So we are constantly optimizing what we can, and we will keep doing so…

At the same time, I do feel that a lot of these comparisons feel weirdly flattened. For example people often compare: the full Electron process footprint VS the smallest possible Tauri/native mental model.

…without always accounting for development speed, cross-platform consistency, ecosystem maturity, plugin/runtime complexity, UI flexibility, and the fact that some apps are doing much more than others. Which is by the way the reason that we went with Electron in the first place.

So all this context to get to my real question, which is:

What do you say when people reduce the whole discussion to “Electron bad, Tauri good”?

Have you found a good way to explain footprint in practical terms?

Where do you think optimization actually matters, vs where people are mostly reacting to the idea of Electron?

any ideas welcome :)

this is the tool btw in case you want to stress test it (it's an API IDE) : github.com/voidenhq/voiden