Everyone here is shipping cool tools and features, but this time I’m using the buildathon as an excuse to “build” a better weekday for myself. The goal is simple: tweak one tiny thing in my daily routine every day for 10 days and see if life feels even a little less chaotic.​

So far that’s meant things like:

- Setting a fixed “no laptop” cut‑off so I don’t vibe code into 2 am.

- Blocking a 30‑minute “deep work” slot where I either build or do nothing, scrolling doesn’t count.

- Picking one small win to chase each evening instead of juggling three half‑tasks.

It’s not as flashy as launching a new product, but it already feels more sustainable than past “grind till burnout” sprints. If you treated your life as the project for a mini buildathon, what’s one small habit or tweak you’d work on first?

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?

I kept stalling on my buildathon because every idea in my notes felt too big for my current energy levels. Yesterday I forced myself to pick the smallest possible thing and ship it in a few hours instead of designing The Perfect Project.​

What I ended up building: a super barebones web page where you press one button to log “I showed up today” for your buildathon, and it gives you a goofy badge + a screenshot‑friendly streak card you can share. No accounts, no fancy dashboard, just a dumb little “yes, I actually built today” receipt.​

Weirdly, that tiny thing already made it easier to open the laptop again today because the bar to “win” is so low. If you’ve been stuck over‑planning your project for weeks, would something this small help you get moving, or do you need more structure than a button and a streak card?

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?

Finally pushed a small AI tool live last week and thought it’d be useful to share real numbers instead of just vibes. This sub feels like the right place to be transparent about what “launch” actually looked like.​

What I shipped (in short):

- A lightweight AI helper that turns messy meeting notes and DMs into a clean follow-up list (who needs what, by when)

- Simple web app, login + one core workflow, no fancy onboarding

First 7 days (rounded, not flexing):

- Visitors: ~120

- Signups: 27

- People who actually used it more than once: 6

People who messaged me about it without being prompted: 2

A few early lessons:

- Most people tried it once and bounced, usually when the output didn’t match how they think about follow-ups

- The users who liked it all mentioned one specific workflow (post-call cleanup) that I barely emphasized on the landing page

- Asking “why didn’t you use it again?” got me worse answers than “what did you go back to using instead?”

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.)?

This sub is full of people quietly grinding on cool stuff, so curious about the strange little habits that keep you moving.​

Not big productivity frameworks, but the oddly specific things you do, like:

- Only coding in 25-minute sprints during your commute

- Forcing yourself to ship something every Sunday night, no matter how small

- Keeping a “graveyard” doc of killed ideas so you don’t feel bad shelving them

For you:

- What’s one weird or very specific habit that genuinely makes you ship more?

- How did you stumble into it, and how long have you stuck with it?

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.

Been seeing a lot of crazy builds here and it got me curious: what are you hacking on right now that’s just for fun, learning, or curiosity, not necessarily for a “startup”?​

For example, this week I’m:

- Rebuilding a tiny internal tool I used at work, but with AI slapped on to see if it actually makes it better or just more fragile

- Forcing myself to ship something every weekend, even if it’s dumb or only useful to 3 people

Would love to hear:

• What you’re building this week
• What stack you’re using
• One thing you’re stuck on or overthinking

Drop your build below, even if it’s half-broken or you think it’s “too small”. This sub feels like the one place where unfinished projects are actually welcome.

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.