u/Deep_Ad1959

the direct deps in my Cargo.toml I sort of track. maybe 20 lines, I picked each one, I roughly know what they do. Then cargo update rewrites the lockfile and cargo tree comes back a couple hundred crates deep, and those transitive ones are what actually gets compiled into the binary.

'audit your dependencies' gets said like the tree is one flat list. It isn't. the crates you chose and the crates pulled in three levels under them are two separate awareness problems, and I only have a real handle on the first. the second layer just quietly accretes every time some direct dep bumps its own deps.

what gets me is the only moment a transitive crate ever enters my head is a failed build or a cargo audit hit. so my early warning system is basically 'it already went wrong'.

so do you actually review the transitive layer, pin it, read anything at all about the crates two or three levels down. Or is it settled-until-it-isn't, which is honestly where I've landed.

I lean on NotebookLM a lot, but almost always for one-off deep dives. dump a spec or a paper in, ask questions, get the audio overview, close the tab. it's a pull tool, I only reach for it once I've already decided I want to dig into something.

the thing I kept wishing existed was the opposite shape. something that wakes up on its own, reads what changed in a repo I follow overnight (the commits, the merged PRs, the issues that blew up), and drops a short episode into my podcast queue before I've decided to care. push, not pull. it's there whether or not I asked for it.

those turn out to be two different builds, not one product with a cron job stapled on. pull-and-deep-dive is a research tool you open on purpose. push-and-ambient only works if you never open it, the whole value is that it shows up during the walk or the commute on its own. I keep landing on the second shape for projects I follow but don't maintain, since those are exactly the ones I never remember to go check.

I lean on NotebookLM a lot, but almost always for one-off deep dives. dump a spec or a paper in, ask questions, get the audio overview, close the tab. it's a pull tool, I only reach for it once I've already decided I want to dig into something.

the thing I kept wishing existed was the opposite shape. something that wakes up on its own, reads what changed in a repo I follow overnight (the commits, the merged PRs, the issues that blew up), and drops a short episode into my podcast queue before I've decided to care. push, not pull. it's there whether or not I asked for it.

those turn out to be two different builds, not one product with a cron job stapled on. pull-and-deep-dive is a research tool you open on purpose. push-and-ambient only works if you never open it, the whole value is that it shows up during the walk or the commute on its own. I keep landing on the second shape for projects I follow but don't maintain, since those are exactly the ones I never remember to go check.

Every morning i run the same loop before anything else, Shopify orders, Klaviyo flows, Gorgias tickets, ad spend. for a long time the number i cared about was how fast i could get through it, a good morning meant a quick scan instead of a slow crawl.

that was the wrong metric. a fast scan just meant i got better at skimming, not that anything actually needed me. the real signal is how many mornings the scan turns up zero actions, because that means the noise got filtered before it hit my eyes and the only things left were real decisions.

i started letting a desktop agent do the cross-app pull first and hand me just the exceptions, a refund spike, a flow that broke, a sku about to stock out. some mornings there's nothing, and that used to feel wrong. now it's the tell that it's working.

the counterintuitive part is a good automated scan should make itself boring. if checking it is still the exciting part of your morning, it's not filtering anything, it's just relocating the pile.

Everyone frames the sales day around the calls, but for me the expensive part is all the prep before each one. pulling the last email thread, the hubspot timeline, whatever got scribbled into the last meeting notes, and where they actually sit in the funnel, all into one view so i'm not cold when they pick up.

the part i underestimated is that assembling that context is a totally different job than logging the outcome after. hubspot workflows are great at the after. the before is this messy cross-app read that no trigger can pre-stage, because you don't know which account you're prepping until you glance at the calendar that morning.

what changed it for me was letting a desktop agent do the gather across gmail, calendar, and the crm and hand me one brief. the thing that made me actually trust it was that it reads everything but doesn't write a single field. reading across apps is fine, it's the writing i still want to eyeball.

where does your pre-call context actually live right now, one tab or nine.

Unpopular take after years of bolting metrics onto my own js projects: velocity charts, commit counts, bundle-size over time, none of it ever told me the actual shape of a week's work. it's all lagging vanity numbers.

the thing that stuck was hearing the repo's week narrated back to me instead. the commits, the one or two PRs, the issues i opened then forgot about, out loud and in order. turns out my week has a storyline i never catch staring at green squares or a grafana panel.

What actually surprised me was how much of my 'progress' was me quietly undoing decisions i'd made earlier in the same week. you don't notice that reading a diff. you notice it when something walks you through the sequence.

so for anyone maintaining a stack of npm packages or one big app repo, be honest: is your dashboard telling you anything you couldn't already feel, or is it a comfort object. what's the last thing you learned about your own coding habits that no tool actually surfaced.

The way i've landed on it: in-app ai and a desktop agent are just two different builds. Notion AI lives inside notion, knows the doc cold, can restructure a whole page in seconds, but it stops dead at the app boundary. what i actually kept needing sat on the other side of that seam, something that reads the notion doc and then acts on gmail and calendar in the same pass, not in a separate chat window i copy-paste out of.

Started running a desktop agent for exactly that a few weeks back. the surprise wasn't the reading across apps, it was that it pauses and asks before it sends or writes anything, so acting across silos never felt like handing over the keys.

connected-and-deep-in-one-app vs reads-and-acts-across-everything are two separate tools solving two separate halves. Notion AI is unbeatable at the first. i just didn't clock how much of my day was actually the second half until something finally covered it.

For a long time I graded practice by two numbers, the streak count and how deep a sit felt. Both are basically vanity metrics. A blissful vibrating sit with no equanimity after it beats nothing, and a dull restless one is sometimes the day the real work happened.

The number that actually tracked change was boring: how fast I recovered from getting annoyed. Anger that used to eat a whole afternoon started burning off in a few minutes, or I'd catch myself snapping mid-sentence instead of an hour later. That's the leading indicator, not the cushion time.

The catch is you're the worst judge of it. I never clocked the recovery getting shorter, someone close to me noticed it months before I'd have admitted it. six courses deep and i'm nobody's teacher, just saying the scoreboard i trusted was measuring the wrong game.

If you track a habit by streak length or how it feels in the moment, watch the 22 hours around it instead. that's where the thing actually shows up. written with ai

For years the number I tracked was the streak: consecutive days sat, and one miss reset it to zero. which meant a single skipped morning quietly became a week off, because the count was already blown so why bother.

the metric that actually predicts whether i'm still sitting isn't streak length. it's the gap between missing and coming back. a two-year run that collapses into a month of not sitting is worse than a sloppy stretch where a miss gets followed by a sit the very next day. short recovery beats long streak, every time.

the tradition's framing on this is almost boringly practical: notice, come back, continue. no ceremony around a broken record, because attachment to a perfect streak is just aversion wearing a productivity costume.

the one thing that's kept my recovery gap short isn't willpower, it's a standing weekly sit with another person. harder to disappear for three weeks when someone's expecting you on the other end of the call. not a teacher here, just telling you what my own log actually rewards.

Six courses in and something like a thousand days of daily sitting, and what actually keeps the habit alive isn't one thing, it's two, and they don't overlap the way i assumed they would.

One is the solo side. same time, same cushion, before anyone in the house is up. that version runs on removing decisions, and the sit belongs to nobody but me. no one to perform for, nothing to report. when it's honest it's honest precisely because there's no witness. but it's also the version that quietly evaporates the first week a work crunch or a sick kid reorders my mornings, and nothing is there to catch the fall.

The other is the witnessed side. a weekly group sitting, or just another old student in my time zone who'd notice an empty chair. that side never made the sit itself deeper, the sit is still only mine, but it makes the return non-optional. the month i'd otherwise vanish for turns into a skipped tuesday someone clocked.

Where i keep landing is that these aren't the good and bad versions of one practice. solo continuity carries the honesty and the depth, witnessed continuity carries the survival. i spent years trying to make one of them do both jobs, leaning on my accountability to make a sit good or on my solitude to keep a streak alive, and neither holds that weight. i'm nobody's teacher, six courses deep and still clumsy at this. but the week i stopped asking each side to be the other one was the week both stopped feeling like effort. written with ai

Spent an afternoon mapping what my hubspot workflows actually own versus what i still do by hand, and it split cleaner than i expected. Workflows are unbeatable for anything i can name in advance: deal hits a stage so fire the sequence, enrollment criteria, set a field, rotate the owner. Deterministic, lives in the crm, runs forever without me touching it.

the other half is the deal where figuring out what to even update means reading a couple gmail threads, the granola notes from the call, and a slack channel since the last touch. that's not a trigger i can pre-write. it changes every deal, and it's the part that quietly eats the afternoon before a pipeline review.

been testing a desktop ai app for that second half, the kind that pulls context across the apps and drafts the update but asks before it writes anything to a record. rule-based-inside-hubspot and judgment-based-across-apps turned out to be two different builds. i kept trying to force the second one into a workflow where it was never going to fit.

the mistake i kept making was treating the across-apps gather as a workflow i just hadn't set up yet. it isn't one. it's a different kind of work, and a trigger engine is the wrong shape for it. written with ai

On our team the engineers basically live in the github feed. PR titles and diffs are enough for them. the problem is everyone downstream: the PM, the designer, the one support person. they have no idea what shipped this week unless someone stops and writes it up, and nobody ever does.

i noticed people are already auto-generating daily AI podcasts off public repos, there's one running for the linux kernel and one for kubernetes straight off the commit log, handed back as a plain rss feed. so i started wondering about pointing the same idea at our private repo and giving the non-eng folks something they listen to on the commute instead of a changelog they'll never open.

what i keep hitting is that these are two different artifacts. The diff your engineers read and the narrative your PM actually needs (this changed for the user, here's why) don't fall out of the same summary, and I keep trying to make one cover both.

so for the smaller teams here, how do your non-engineers actually find out what shipped. a slack post someone writes by hand, a loom, standup, or does it just quietly not happen until a customer asks about it.

Hot take after trying a pile of these mac ai agents this year. The ones that ran fully autonomous got uninstalled inside a day, and not because they were dumb. i just couldn't watch what they were doing to my actual gmail and calendar.

the one that stuck does the opposite of what the demos sell. it drafts the email or the calendar change, then stops at an approve-this-action prompt before anything leaves the machine. honestly feels like the same TCC dance macOS already makes you do for screen recording and full disk access, just at the per-action level instead of once per app.

every AI thread treats that prompt as friction to engineer away. i think it is the entire product. something that silently edits my hubspot while i'm looking elsewhere is a liability, not an assistant.

the autonomous-agent crowd can keep their magic. i'll take the one that asks first, every time. written with ai

Was closing a single customer last week and looked up to find 28 tabs spread across four chrome windows, all of it for that one deal. gmail thread, the shared doc, the crm, slack, their linkedin, a couple notion pages i'd opened and forgotten. that pile was the context i was holding in my head just to push it forward.

what got me wasn't the count, it was realizing almost none of it was thinking. it was fetching. pulling the same handful of facts out of a handful of apps to make one call, then typing the result back into the ones that needed it. i'm the integration nobody built.

i've been handing that cross-app pull to a desktop agent that can actually read the apps and take the step instead of just describing it, and the tab pile for that kind of task got a lot smaller. the part i didn't expect to care about: it stops before anything irreversible and makes me approve it, which is the only reason i let it near a live account.

the question i keep landing on is how much of a founder's day is real decisions versus just being the wire between tools that should already talk to each other. mine is way more wire than i'd like to admit.

Hot take after years of doing this: subscribing to dev podcasts to keep up with your stack is mostly a way to feel productive without actually doing anything. My queue is full of interview shows about frameworks I half use, and i finish almost none of them. The ones that actually get played are short and about something i touched that week, the new react compiler behavior, a postgres point release, whatever broke my build.

The format is the problem, not my discipline. A two-host interview that rambles for an hour and a half ages out before i press play. What survives my queue is closer to a changelog read out loud. a few minutes, no intro music, just what shipped that day.

so for the js folks who commute or walk a lot, what's actually in your rotation that you finish start to finish, versus the shows that have been sitting at episode 1 since forever. written with ai

the meeting was never where my week leaked. it's the 30 minutes after. i've got call notes, three action items, one follow-up email to send, and a couple deal fields to update in hubspot. by the time i've turned the notes into a task, opened the deal, updated the stage, and drafted the email, the next call started and one of those four things quietly didn't happen.

What i finally clocked is the work doesn't die inside hubspot or inside my notes app. it dies in the handoff between them. nobody owns that seam, so it's the first thing to drop when the day compresses. granola to linear to gmail to hubspot, four tools that each assume someone else is carrying the baton.

the thing that moved the needle wasn't a better notetaker or a cleaner pipeline view. it was letting something read the call notes and turn them into the task, the draft, and the field update in one pass, then stop and make me approve each one before it writes anything back to the deal. that approval gate is the only reason i let it near a live record. the part i underestimated was how much of the loss was structural, not effort. I was never sloppy about follow-up, the relay just never had an owner. written with ai

Everyone benchmarks these desktop agents by the integration count. 40-something logos on the page, look how many apps it talks to. A few weeks in, that stopped being the number I'd watch.

The thing that actually mattered was the opposite: what it does when there's no integration. A big chunk of my real work sits behind some internal portal or vendor dashboard with no api, and the agents that only speak to the official connectors just stop at the edge of their list. The one that stuck shipped its own browser and would go click through the thing by hand, then write the result back into the app I cared about.

it's another bundled chromium sitting in ram, which on this sub i know counts as its own crime. but the metric that predicts whether one of these survives past week two for me isn't how long the logo wall is, it's whether it can finish the one task on the other end of a site that has no api. written with ai