Add one weekly session well above threshold, limited to once per week
Bakken recommends adding one session each week where you go harder, well above threshold, where you can push the pace, but limiting it to once a week.
39,816 results · Most relevant
Bakken recommends adding one session each week where you go harder, well above threshold, where you can push the pace, but limiting it to once a week.
Bakken endorses that with threshold work, one easy day after the session is usually sufficient, so you gain control over the recovery window.
When reaching out to an executive after meeting their team, open with a script that names the team members, summarizes their main hurdles, quantifies the impact, and asks to validate the perspective together.
Set a redline deadline — a set of deadlines for when the customer's legal team delivers first-round redlines, when you respond, and when they return their second response — to project-manage the vendor review stage. Be maniacal about project-managing the customer through the legal process once you send over a contract, because that stage is where sellers most often fail. Even without a commercial give-get to back it, set the deadline anyway: just stating it incentivizes the customer to hit the dates and gives your champion leverage to push their legal team.
Get the next meeting in the calendar before ending the conversation — if you are losing deals, this is probably why. Depending on your ICP, prospects will really respect the practice.
hedged
Early in the sales process, meet with end users to learn what is working and what is not, then package those findings into a point of view that can be used as leverage to secure a call with the executive team.
The moment you are picked as vendor of choice, ask your champion to kick off procurement, security, and legal at the same time instead of sequentially — this alone can turn a six-week review into two weeks.
Daksh Gupta lays out a basic recipe for building a review agent: get yourself a sandbox (you can use Firecracker instead of buying one from a vendor), put an agent in the sandbox (the agent can be Codex or Claude Code; he personally recommends going model independent, using something like OpenCode or Pi as an open-source harness), connect your GitHub or GitLab with a PR webhook that sends the contents of a pull request when it is opened, give the agent a simple prompt like 'review this and send back some feedback', and wire the agent's feedback back using GitHub's review APIs. About five minutes later, you will get some feedback on your pull request.
Kevin Hou describes an agent-automated eval workflow: load a skills file and ask questions in natural language; take a set of tasks and run multiple rollouts; compare control vs experiment tables and ask the agent to compute the delta; have the agent propose hypotheses for why deltas occurred; spin up subagents to investigate each hypothesis in parallel and map results back to a single response; review the report and interact with the data via generative UI (dropdowns, filtering, segmenting, slicing); then iterate for a better next experiment. He notes this replaced slow manual Jupyter Notebook analysis and hand-engineered judge pools and data pipelines, turning a very manual eval process into one that takes minutes.
hedged
Roland Gavrilescu recommends optimizing for valued work per watt: first make sure the work you're generating is valuable, then make sure the economics makes sense — the difference in price is basically what people would switch away from Cloud Code to something you provide.
Roland Gavrilescu recommends that loops should be the way you distill systems into recipes: failure patterns should become judges and evals, repeated behavior should become skills and prompts, and user frustration should become extensions and memories to your harness.
Roland Gavrilescu says the calibration bit and the eval generation bit should be doable by agents to build. You need a human in the loop to confirm the approach and agree with the agent's judgment (e.g., whether to look for hidden gems rather than big tech employees) — but you don't need the human to actually build the evals; you need them to calibrate the evals. Agents should be the ones that take the taste of the maker and put it into code.
Roland Gavrilescu says you can have a good offline eval set, but the real test is when you go to prod — whether the end user agrees with your taste. He recommends building a product that emphasizes your taste, then making sure your users appreciate and value that taste, using A/B tests — or a multi-armed bandit scenario — to make sure that's the case.
Carson describes how Untangle runs its AI engineering org: humans at the top set priorities and talk to customers; manager agent sessions (named 'engineer manager') never write code and manage child builder agents; Devin is the cloud coding agent for all engineering work; the manager works from a Linear ticket board as the source of truth, with every ticket being one PR; each manager concurrently manages up to about 20 builder agents (varying 5–25), bottlenecked by your ability to talk to the manager and understand what's happening — pushing beyond ~25 builders per manager will quickly spin out of control; you never go into builder sessions directly, all management goes through the manager agent; the manager usually answers technical questions and unblocks small things; an automation (a 15
Carson describes the human-in-the-loop step where a human has to say 'ship it': the manager session lets you know a video is ready; you zoom in and understand what the PR is doing by reading a summary, then watch and engage with the video; watching the video is the part where you'll want to cut corners, but you have to watch it — it's the bottleneck you must engage in as a product owner; review videos on your laptop, not your phone, because you need to see them well enough; he recounts being on his phone before the talk, tempted to say 'ship it' without seeing the video well, and getting back to his machine instead.
Carson describes the second stage: pick the top five stack-ranked candidates and invite them to a paid project — a fixed fee for 16 hours of their time, with a seat on Devin; ask them to get a real PR ready for merge; have them sign an NDA and record all their video (using Loom, producing 16 hours of video per round); feed all the videos into an agent (Devin) and ask which candidate to pick; then pick your finalists. He notes he personally watched all 16 hours for the last round — brutal, but it gave him a good read on the people.
Carson describes the entry stage of Untangle's hiring: ask candidates to submit a ~45-minute whole-screen recording of themselves shipping a feature (a PR, typically) on an app they already maintain, with no instruction or guidance — you just want to see how good of an agent operator the person is; the submission is free (the company doesn't pay for it) and is basically how you get in the door; feed the videos and transcripts into a ranking agent that watches the video and transcript and stack ranks the people; if you have time you could watch all the videos yourself, but he finds a very intelligent model is pretty good at understanding how good a candidate is; some candidates mumble or don't think out loud so you can't tell what they're thinking, and some talk a lot, so evaluation signals
hedged
Roman Ugarte recommends giving each specific bot a name and a bot identity, and creating a bot per task or use case rather than a thread conversation or one-off job. He says the naming piece is a very important part of making the bot feel like a colleague, and discourages creating a new chat for each discrete unit of work, suggesting instead roles or swim lanes to group categories of work, the way a team groups work by role.
hedged
Roman Ugarte recommends treating AI bots like new human colleagues: give each bot its own laptop, credentials, and workspace instead of sharing yours, and give it access to the same tools you use to do your job. He argues that a bot with its own computer and the right tools can get a lot of the way there and do great, ambitious work.
Hassan describes the end-to-end pipeline they built: scrape public filings, timestamp extracted facts, filter to a pre-announcement cutoff date, use a recent model to translate the question into structured JSON, feed it into a cheap open-weight model that builds an auditable Excel financial model with explicit formulas and assumptions, run many parallel builds, discard failing runs, and evaluate predicted profit against actual profit from earnings reports.
Choose sources → to get a library of your own and a daily brief.