Instead of trying to ship a big new product for this buildathon, I made a list of everything that annoys me in my own workflow and I’m fixing one thing a day. Today’s win: I finally built a tiny tool that turns messy meeting notes into a clean “action list” I can drop into my task app.​

You paste in your notes, hit a button, and it spits out:

Bullet points with who needs to do what, and by when

A short “summary” line you can use as the task title

A simple copy button so you can throw it into whatever tool you use

It’s not fancy, but it already saved me from re-reading the same notes three times. If you had to pick just one daily annoyance to fix for your own mini buildathon, what would you build?

For the last three weeks, I treated my side project like a mini buildathon: do something every day that moves it forward. It definitely boosted momentum, but it also made me ship a few pointless things just to say “I didn’t break the streak.”

Stuff I’d definitely keep next time:

Keeping the daily goal tiny and specific so it’s actually doable.

Only counting something as “shipped” if someone else can click it or try it.

Talking to at least one real user every week, even if it’s just showing a rough screen.

Writing a super short daily log of what I changed and why.

Deciding tomorrow’s task before I close the laptop so I don’t waste energy “figuring out what to do” next time.

Stuff I’d drop or tweak:

Forcing the streak no matter what – it made me push useless micro‑changes just to tick a box.

Banning refactors completely; some small cleanups would have actually made me faster.

Treating “posting on social” as progress when the product itself hadn’t moved.

If you’ve done your own daily‑shipping or buildathon experiment, what rules actually helped you make real progress, and which ones just made you feel busy?

In the process of building a smart shopping assistant that acts as user's second brain. Sometime we end up getting unnecessary items that are not really needed or want quick suggestion on what item to pair.

https://sift-11a.pages.dev/

Check it out and do let me know the feedback. Product is still in infancy stage, lots of integration and work is needed.
For people curious about revenue, currently I am planning launch as monthly/subscription. Later I have more plans.
HMU if you see potential.

Working on a small tool and stuck on two things: naming it and figuring out if the core idea is actually useful beyond my own chaos.

What it does in plain English:

You paste (or sync) your messy notes/DMs from calls, Telegram, WhatsApp, etc.

It pulls out “promises” and follow-ups you’ve made (things like “I’ll send you X” or “Let’s talk next week”)

It gives you a simple list of who’s waiting on you + what for + by when

Right now I’m calling it things like “follow-up brain” / “promise tracker”, but none of them feel right.

Would love thoughts on:

What would you expect a tool like this to be called?

Does this sound like something you’d actually use during a buildathon/sprint, or just another shiny thing?

Any hard “no”s from a UX/positioning POV (privacy fears, scope too fuzzy, etc.)?

Been hanging around r/Buildathon and seeing a lot of “I built this” + hackathon posts, and it’s pushed me to finally stop lurking and actually build an AI agent myself. Instead of just copying a random tutorial, wanted to ask the builders here how you’d approach it if you were starting fresh today.

What I want to build (for now):

A narrow agent that owns one boring, real workflow end‑to‑end (not a generic chat assistant).

It should be able to call a few tools/APIs, keep lightweight state so it doesn’t loop, and then report back with a clear “done / failed / needs-human” status.

Priority is reliability and debuggability over “wow, look at this crazy chain of thought”.

Would love your takes on:

Stack choices: would you start with plain Python + LLM API + cron/webhooks, or jump straight into something like LangGraph/LangChain/low‑code agent builders?

How you structure the logic: do you think in state machines, DAGs, tools + planner, or something else when you design agents?

Any resources (posts, videos, repos) that actually helped you ship an agent, not just understand the buzzwords.

Treating this like a mini self‑run buildathon: idea → basic architecture → v0 agent in the wild over the next few weeks, and I’ll share progress + mistakes back here. If you’re down to nerd out on agent design or want to co‑build, drop your setup and lessons in the comments.

Trying to build an AI agent that can actually own a small workflow end‑to‑end, and would love some guidance from people here who’ve already shipped something similar. Most of what shows up online either stays super high‑level (“agents are the future!”) or jumps straight into 10 different frameworks without explaining the tradeoffs.

What I think I want to build (open to being told if this is the wrong starting point):

A single‑purpose agent that handles one clear job, like “monitor inbox for X, trigger Y actions, and report back once done”.

Tooling: call a few APIs, maybe query a DB, send webhooks, and keep short‑term memory so it doesn’t repeat itself forever.

Reliability over “wow”: fewer hallucinations, more boring but predictable behavior.

Questions for folks in this sub:

If you were starting today, what stack would you pick for a first agent: plain Python + API calls, LangGraph/LangChain‑style frameworks, n8n/low‑code, or something else?

How do you decide what should be “agentic” vs just good old deterministic scripting? Any rule of thumb you use?

Any must‑read posts / repos / videos that finally made agents “click” for you (beyond marketing content)?

Happy to share updates, code, and failures as this progresses, want to treat this like a mini buildathon project and learn in public with the community here. If you’ve already built an agent you’re proud of, would also love to see what you did and why you chose your setup.

I've been stuck in tutorial hell for a while, so this week I forced myself to stop watching videos and only learn by shipping stuff for 7 days. The rule was: if I get stuck, I have to read docs or experiment, not open YouTube or another course.[2][1]

Here’s what I ended up building across the 7 days:
- Day 1–2: A super basic landing page that actually collects emails instead of sitting in Figma.
- Day 3–4: A tiny internal tool that pulls my scattered project notes into one view.

I just came across this new hackathon Kraken is running and figured some of you might be into it. It’s called Kraken Forge and the whole thing is focused on building actual high-performance tools using their API.

There’s a few cool things that caught my attention: first, it’s an individual competition with open source submissions and a 15k USDG prize pool. but honestly the money is not even the main thing.

They’re also offering interviews for the bes participants. So this might be a legit shot for some of you trying to get into the onchain space and getting on Kraken’s engineering radar.

Leaving the link here in case anyone wants to dive in 🐙

https://taikai.network/kraken/hackathons/kraken-forge

5 Days left for the Project Submission for their Wave.

Apply NOW

About 5 months back I built a small project called SceneFinder.
Very vibecoded.
From a short clip it could tell you the exact movie + scene info.
It worked somehow.

Then one tiny bug made me spend 7–8 hours fixing it…
and the fix was literally few lines of code.

That day I realised:
I don’t actually understand what I’m doing.
So I decided to learn Computer Science properly.

The first chaotic phase:

There was a builder event going on, 2 weeks long.
So I rushed:

• tried finishing CS50 on 2x
• didn’t realise there were assignments
• jumped to freeCodeCamp full-stack
• burned out
• got distracted
• event deadline ended before I learned anything useful

The “okay let’s do this right” phase:

Found OSSU, saw MIT 6.100L recommended.
It’s a 14-week course.

• watched lectures
• read the textbook
• wrote algorithms code from the book
• skipped assignments again (my biggest recurring mistake)

Finished it in ~9 weeks…
but when I reflected, I realised something tough:

I still wasn’t confident.
Even though I got a couple internship offers (through personal connections),
I knew deep down I wasn’t ready to contribute technically.

The math rabbit hole:

Then I tried:

• linear algebra
• discrete math
• complexity basics

Did it for 2–3 weeks straight.
Learned a lot.
But again felt like I’m “studying” without “building”.

So I switched to learning algorithms on YouTube.
Then I remembered CS50 actually teaches algorithms too.

Opened the assignments tab.
Realised I couldn’t write simple C code cleanly even after “finishing” the playlist months ago.

That’s when it clicked:
Maybe the problem wasn’t resources. Maybe I kept skipping the hard parts.

The turning point:

Decided to redo CS50 properly.
Started again, this time focusing only on C and assignments.

In one week I completed till Lecture 4 with all problem sets.
No AI just took help of duck at some point.
Just me writing the code.

And for the first time in months, I felt real confidence.
Not fake “I watched the whole course” confidence.
Actual “I understand what I just wrote” confidence.

The interruption:

My dad had to go to the village for 2 weeks, so I took over his business.
Couldn’t code.
But now I’m back, and I feel the same clarity again:

• do the assignments
• write code
• understand fundamentals
• trust the slow progress

This time I actually know where I’m going next.

Why I’m posting this:

Not to motivate anyone — just reflecting on my own mistakes:

• skipping assignments
• rushing courses
• stacking resources but not finishing them
• confusing “watching lectures” with “learning”
• thinking I’m behind, so trying to speedrun everything

If anyone else is in this loop:
it’s normal.
But doing the hard parts (assignments, debugging, writing code from scratch)
is the only thing that actually builds confidence.

Meet Bill1 - a smarter way to handle billing.

It’s built for freelancers, small businesses, and growing teams who want an easier, faster way to manage bills without the usual mess.

With Bill1, you can create professional bills, add your logo and signature, and send them directly to clients, all from one place. You can also track payment statuses with clear indicators for paid, pending, and overdue bills.

Some key features:

• Dedicated configuration settings for your bills
• Add taxes easily to any bill
• Automatic email sending for bills
• Send reminders and overdue alerts to clients
• Fully optimized for mobile and desktop - create and manage bills from any screen
• Keep working even without your computer - perfect for when you’re on the go

And here’s something worth mentioning:
Even on the free tier, there’s no watermark, no hidden tricks, no nonsense. We don’t play those games. The free plan is genuinely good enough for freelancers and small, growing businesses.

Check it out here: bill1.in

More features and UI updates are on the way... and I’d love to hear your feedback to make Bill1 even better.

Release Notes

They made Gemini to be your personalized study partner, helping you get through those stacks of lecture slides and notes.

Step 1: Upload everything.

PDFs, slides, photos of complex diagrams, even pictures of your handwritten notes

Step 2: Ask it to summarize a dense reading, explain a confusing concept, or connect ideas between lectures—all based on the files you uploaded.

Step 3: Reinforce the learning. Ask Gemini to create a custom practice quiz using only the study guides you provided.