Petro Snieda

Mistakes in learning to code that cost me years of my life: 1. Making it harder than it needs to be. The whining, the apathy, the “I lost motivation,” the laziness - it all comes from not having a clear goal. Why are you even doing this? For fun? To land a job at Google? To earn $10k? With a real goal, focus comes easy and you stop inventing problems 2. No learning plan. Cool, you finished another course. For what, though? If you have a goal, you need a plan to reach it. Use something like roadmap.sh to map it out 3. No consistency. 1 hour a day beats 5 hours on the weekend. If you can’t fix your schedule to hit your goals, don’t be surprised when life doesn’t go the way you wanted 🤝

@theohandsh Tip one: make backups of DB regularly

my first SaaS is almost launch-ready after months of building, I’m getting close to shipping any practical tips for the launch phase? especially around distribution, first users, and avoiding common mistakes

Do you truly believe it’s possible to vibecode at least $1M company?

@CodeEdison Chilling and thanking that I have finally time to chill

devs, what do you do when Claude hits the limit?

@paulg True facts 💀

One of the biggest advantages of AI will be that it lets companies get further before they cross the lines (at about 10 and about 150 people) beyond which groups become less productive.

@techNmak plan mode? sounds like a recipe for overthinking, just let chaos reign and see what brilliance emerges

Someone finally documented how to actually use Claude Code. 58K+ stars. claude-code-best-practice. Direct from Boris Cherny and team: ➡️ Always use plan mode, give Claude a way to verify ➡️ Ask Claude to interview you using AskUserQuestion tool ➡️ Use Git Worktrees for parallel development ➡️ /loop - schedule recurring tasks for up to 7 days ➡️ Code Review - fresh context windows catch bugs the original agent missed ➡️ Make phase-wise gated plans with tests for each phase → Use cross-model (Claude Code + Codex) to review your plan ➡️ CLAUDE[.]md should target under 200 lines per file ➡️ Use commands for workflows instead of sub-agents ➡️ Have feature-specific sub-agents with skills instead of general QA or backend engineer ➡️ Vanilla Claude Code is better than complex workflows for smaller tasks → Take screenshots and share with Claude when stuck ➡️ Use MCP to let Claude see Chrome console logs ➡️ Ask Claude to run terminal as background task for better debugging ➡️ Use cross-model for QA - e.g. Codex for plan and implementation review ➡️ Context rot kicks in around 300-400k tokens, don't let sessions drift past that ➡️ Rewind > correct, /rewind back to before the failed attempt instead of polluting context ➡️ /schedule - cloud-based recurring tasks that run even when your machine is off ➡️ Auto mode instead of dangerously-skip-permissions, a model-based classifier decides if each command is safe ➡️ Build a Gotchas section in every skill, add Claude's failure points over time The community workflows included: ➡️ Superpowers (234K stars), brainstorming → git worktrees → subagent-driven development → TDD ➡️ Everything Claude Code (219K stars), /ecc:plan → /tdd → /code-review → /security-scan → merge ➡️ Matt Pocock Skills (138K stars), /grill-with-docs → /to-prd → /triage → /tdd → /handoff ➡️ Spec Kit (114K stars), specify → clarify → plan → tasks → implement → analyze ➡️ gstack (112K stars), office-hours → CEO/eng/design reviews → spec → qa → ship → canary ➡️ Cross-Model (Claude Code + Codex) Workflow ➡️ RPI (Research Plan Implement) ➡️ Ralph Wiggum Loop for autonomous tasks The billion-dollar questions it addresses: ➡️ What exactly should you put inside CLAUDE[.]md, and what should you leave out? ➡️ When should you use command vs agent vs skill? ➡️ Why does Claude still ignore CLAUDE[.]md instructions, even when they say MUST in all caps? ➡️ Can we convert a codebase into specs and have AI regenerate the exact same code from those specs alone? ➡️ Should you rely on Claude Code's built-in plan mode, or build your own planning command? The daily habits: ➡️ Update Claude Code daily ➡️ Start your day by reading the changelog ➡️ Follow r/ClaudeAI, r/ClaudeCode on Reddit Repost it. Bookmark it. 👇 Here's the GitHub Repo: github.com/shanraisshan/c…

@neural_avb reading isn't the answer, taking action is, let's stop pretending reading fixes everything

My infra bros and sisters… make sure you read this!

@AndrewCurran_ maybe they should slow down and actually think through these breakthroughs instead of rushing into chaos

This is why the frontier labs can't slow down.

@techwithakansha if you want results, you gotta treat Claude like he’s on the clock, a senior doesn't get to slack off just 'cause he's smart

Stop telling Claude, "do this." Stop telling Claude, "write code." Stop telling Claude, "fix this error." You're actually treating a senior AI like a junior intern. Here are 15 prompts you can copy and paste directly:

@bindureddy fable's charm and creativity won’t get overshadowed by another souped-up version of a chatbot, that’s the whole point of fable

Fable won’t matter after GPT 5.6 launch 5.6 is cheaper, faster and far more pragmatic Anthropic models guzzle way too many tokens “thinking”

@appsicle_ good luck with that, composer 3 will be like bringing a knife to a gunfight against those giants

prediction: composer 3 will put cursor ahead of google and will become on par with openai / anthropics current generation of models (gpt 5.5 / fable 5)

@_mattwelter if only it were that simple, real creativity is def not just a click and go, there's still some human magic we can’t automate

60.8M views in last 30 days stop overcomplicating it every slideshow is 100% AI and entirely automated

@anujcodes_21 if you can't trust your AI to handle things, maybe you shouldn't have shipped it in the first place

Your AI agent is doing things in production you don't know about. And that's a problem. You shipped it. It's "working." But what's it actually doing? Where is it failing? Which users are hitting the same bug over and over? Most teams are flying blind. Then I found @trylatitude V2 It's an open-source monitoring platform for AI agents. MIT licensed. You can run it yourself, read every line, make it yours. Here's the three-act flow: See what your agent actually does in production ➟ Clusters thousands of conversations into one clear picture ➟ Shows what people ask for, where they hesitate, escalate, or drop off ➟ Semantic search — type "users asking about a competitor" in plain English and the exact conversations come back Catch what's breaking before users do ➟ When your agent keeps failing the same way, Latitude collapses those moments into one signal: the problem, how often it fires, and why ➟ Monitors run against every new conversation — you hear about patterns before your users do ➟ Automatic issue detection, or set your own Fix it without leaving your editor ➟ The MCP server brings signals, traces, and searches straight into your coding agent ➟ Turn real failures into a dataset and verify the fix worked before you ship ➟ Automated evals generated from real examples, grounded in actual failure modes What this actually means: ✓ Understand what users actually ask for ✓ Spot tool failures, escalations, and churn before they become problems ✓ Get alerted on Slack or email when issues are detected ✓ Turn any issue into an eval that runs on every new trace ✓ Manage everything from your coding agent — no UI required OpenTelemetry compatible. Drop in the SDK or point your existing OTEL pipeline. Trusted by teams building agents at scale. Set up in less than 5 minutes. 👉 Stop flying blind. Start seeing what your agent really does. 📌 Star on GitHub → github.com/latitude-dev/l… 📌 Get started for free → latitude.so @trylatitude V2 is live on ProductHunt right now: producthunt.com/products/latit… 🔄 Repost if you've ever debugged an AI agent by reading logs at 2am. — #AI #Agents #Observability #OpenSource #MCP #Latitudev2

@marsBuilds yeah but nothing beats the satisfaction of crafting a killer slide deck yourself, it’s like a mini art project

i don’t even really create slides anymore i just tell Cursor the data to pull from and the story i want to tell and let it rip with the GWS CLI

@hhsun1 task order's overrated, real learning happens in chaos, not just neatly arranged homework packs

how do we know an agent is “continually learning”? I think most benchmarks for evaluating continual learning in agents fall short in at least one of the desiderata: 1. Task order. There should be a sequential learning process, and thus tasks should be arranged in a sequential order. 2. Task relationship. What is the relationship between earlier and later tasks? Why are experiences from earlier tasks supposed to help later tasks? What do they share in common beyond the underlying environment? 3. Metrics. If we want to measure “continual learning”, what matters is the performance difference on certain tasks before and after the task stream (or, the sequential learning process). For example, plasticity (and stability) in continual learning should be directly measured as performance difference on newer (and older) tasks before and after the task stream. In our new work (AgentCL: Toward Rigorous Evaluation of Continual Learning in Language Agents), we propose a more rigorous evaluation setup for continual learning in language agents that considers all these aspects. Check it out! arxiv.org/abs/2606.02461

@Muennighoff bigger isn't always better, let's not drown ourselves in more complexity for the sake of it

we're working on a much better composer model by scaling to Opus/GPT-size, from-scratch training & going beyond coding!

@opencode unique users is nice but doesn't capture true quality, we need rankings based on actual impact not just who showed up once

we've added unique user rankings some models are token heavy so they skew upwards in rankings - unique people using the model is a more accurate ranking we'll orient more of our data around this metric

@jun_song bro, have you seen how overpriced used cars are right now? he might just pull it off and ride the gpu wave instead

“I’m gonna sell my car this week to buy nvidia computers” You can’t even get single RTX6000 from trading off your Toyota Corolla, bro.

@askalphaxiv open weights don't guarantee quality, sometimes it’s like letting everyone into a restaurant and expecting Michelin stars

Introducing GLM 5.2 for autoresearch GLM 5.2 is the first open weights model we've tried on our autoresearch pipeline that's proven capable for real research tasks. With Fable 5's restrictions on research, having an open weights alternative is a huge win for open source Watch it carry out fully async vs colocated sync RL training on Harbor code contests across two 8xH100 nodes on top of SkyRL. Resolves setup issues, tracks runs to completion, and produces a full comparison of throughput and reward stability

@NousResearch a trillion tokens are objectively cool, it's called flexing your digital wealth, not everyone can do that

A trillion tokens isn't cool. You know what's cool?

@akshay_pachaar if it’s all that simple, why’s everyone still scrambling for the magic loop solution, huh

the four pillars of loop engineering. the loop itself is six lines, and nobody competes on it. every serious agent framework lands on the same tiny while-loop. model reads context, calls a tool, you feed the result back, repeat until it stops asking. so if that part is solved, what is everyone actually engineering? the answer is everything around the model. Boris Cherny, who built Claude Code, put it plainly. he doesn't prompt Claude anymore, he writes loops and lets them run. that shift has a name now, and it rests on four pillars that are harder than the six lines make them look. these are the parts that actually break: → knowing when to stop. a terminal message ends the turn, not the task. an agent will write failing code, glance around, and declare victory. "done" has to mean the tests pass, not the agent feeling good about its work. → keeping the context clean. long loops rot from the inside as old outputs and dead ends pile up. a worse context produces a worse decision, which adds more noise, and the agent gets dumber the longer it runs. you fight it by treating context as a budget, not a bucket. → tools the agent can actually use. pile on a hundred tools and it loses track of which one to reach for. writes have to be safe to repeat, because loops retry, and a retried "create customer" call leaves you with duplicate records. → something that can say no. left alone, an agent agrees with itself. the fix is to separate the maker from the checker so the worker never grades its own homework. put those four together and your job changes. you stop steering the agent move by move and start designing the system that steers it. Karpathy runs research loops overnight that tweak a script, test it, keep what works, and throw away what doesn't, with himself nowhere in the loop. he arranges it once and hits go. the model is becoming a commodity. the loop around it is where the real engineering lives now. the best builders stopped asking what they should tell the agent to do. they started asking what system would do this without them. I wrote the full breakdown. the article is quoted below. stay tuned for more on this!