35,682 results · Most relevant
Create a saved Sales Navigator search of your accounts filtered to first-degree connections and save it so you receive lead alerts whenever a first-degree connection changes jobs into your territory, letting you capitalize on the newness of the move.
Set up a 'viewed your profile recently' alert filtered to your current company account lists to catch anyone in your territory checking you out. Don't filter by seniority or geography — anyone in your territory looking at your profile is worth engaging, from BDR to marketing coordinator.
For a first-degree connection with no open opportunity, send a nurture note with a helpful article related to something you sell, can help with, or a past shared passion — not a sales pitch. When a senior manager from a company where you have an open opportunity views your profile, send a connection request referencing your work with their team without calling attention to their tie to the deal. For a stranger with no open opportunity, send a connection request noting you work with their industry peers on a specific challenge and offering help or a chat.
Save every deal's stakeholders — the people you're multi-threaded into — into a Sales Navigator list at close, so you can track them via 'client job hopper' searches and get notified when they change jobs and where they go. This approach uses lists rather than saved searches.
To track customer execs changing jobs, filter Sales Navigator by current company (your territory) and past company (an account list of your biggest logos, e.g., Fortune 50 that work with you, or by verticals like law firms or pharma). Narrow by seniority level and geography, or large companies with people moving around will flood you with results.
Set up a Sales Navigator search that alerts you anytime a new executive joins your own organization. New executives are eager to make a fast impact and can drive value in about 15 minutes, and connecting with them is one of the fastest ways they can make that impact.
Pamela Fox walks through the concrete setup for an LLM judge: put the LLM in judge mode and tell it it is an evaluator, tell it what it is evaluating, give it the query and response (plus context for groundedness), and force it to output a pass/fail verdict together with a reason.
Put the LLM in judge mode by telling it it is an evaluator and what it's evaluating. Give it the query and the response as inputs; for groundedness, also give it the context. Force a binary pass/fail decision, have it also give a reason, and ask for JSON output so results are parseable.
Pamela Fox walks through a repeatable workflow: check whether the model calls the right tool and passes expected arguments; treat wrong arguments as a signal of ambiguity in the description; clarify the description with explicit constraints (e.g., 'don't include me or you, just named attendees', 'first and last if provided'); then re-evaluate across all inputs.
Pamela Fox recommends using DSPy to avoid manually tweaking prompts per model: declare the program's constraints (e.g., take user input and turn it into a structured calendar event) and DSPy figures out the prompt that adheres to them. She also advises setting up checks/tests to verify whether output satisfies each constraint so DSPy can iterate, and providing the student model and reflection model so it can run the optimizer.
The speakers demonstrate a proof command using Playwright to verify end-to-end behavior: taking screenshots to verify UI state, checking the inner text of a status element to confirm the email address appears, checking storage state after an action to verify data was actually persisted (e.g., an email saved to the waitlist), and using reload and snapshot together to confirm state survives a page reload. They also note checking rendering at different widths and in dark/light mode to catch rendering bugs that affect real users.
Laurie Voss recommends giving the faithfulness judge the full context — raw search results plus the agent's research notes — not just the notes. If you only give it the research notes, it will flag numbers as made up because it doesn't know the web search actually found that data. The getAgentRuns helper pulls both.
Laurie Voss recommends pointing a coding agent at traces to look for weird things, claiming coding agents are aces at reading traces, while keeping manual inspection as a sampling technique since agents won't always find what you expected.
The simplest useful code eval checks whether the report mentions the ticker symbol of the company asked about — a binary check where using an LLM would be overkill. It found real errors (Tesla and Amazon reports missing their tickers; the Amazon one wrote only about AWS), and it costs nothing to run.
Open a branch on a tagged challenge: a separate agent tasked with reviewing the plan, reviewing the assumptions, and doing healthy challenge.
endorsed advice
Try the simplest method first, then try something a little more complicated, and check whether the performance lift justifies the additional complexity. If it does not, stay with the more interpretable method. The guest notes there is a lot of temptation to go straight to neural networks and transformers, but that is often not the right way to go.
We need something in the very near term before an NTSB for AI could be set up — could be a not-for-profit. We need a non-punitive reporting system for AI safety, best practices plus postmortem analysis, and something like US GAAP for AI: generally accepted AI deployment principles with auditors (like KPMG or Ernst & Young) you can choose from. We should also take validation of AI seriously from a number of different perspectives.
Applying the Swiss cheese model to large language models: we control the training data, the pre-train, the RLHF, the RSI, all the data being sampled, and we can take out the bad data. Percy is reportedly running a small model to look over the pre-train data to remove bad stuff so the model can't possibly learn those bad things. After cleaning training data, the next layers are: do a failure analysis on the data, estimate failures, sample some failures, estimate failure modes, get to a p fail (or one minus p fail, which is p success), then tools, and all the way to runtime monitoring. Clark adds that you need all these layers — the opening-remarks example had the chain of thought monitor turned off, which would be one of those layers.
Have the best agent do planning, a faster cheaper agent do implementation, and the best agent for review again. Faster cheaper models like JRM 5.3 Flash can do implementation tasks at the same quality level as stronger agents when a stronger agent does the planning.
Add an extra step between observing and reasoning — something like 'recall long-term memory' — that lets the agent recall memories and makes it introspective before solving the problem. The recall step goes to the vector store (or wherever the long-term memory episode from a previous conversation is recorded) and pulls from it if the agent considers it interesting. This acts like an additional abstraction between the observing and the reasoning parts of the loop.
creator's recommendation for the loop design
Use saved training trajectories and a controlled intervention to explain a failure, separating equilibrium theory from observed empirical stability.
Demonstrate all 3 repaired bugs and defend why a passed gradient check is necessary but not sufficient for generalization.
Use the tractable fixture and posterior predictive results to separate approximation, sampling and model errors; justify one revised modeling assumption.
Choose sources → to get a library of your own and a daily brief.
Map each implemented component to the original paper and explain 2 reduced-model failure modes without claiming full-scale reproduction.
Use calibration and shift measurements to justify a monitoring or abstention threshold, and give an explicit confounding counterexample to causal feature-attribution claims.
Defend a causal claim or refusal using the DAG, numerical estimates and a counterexample showing why predictive model fit cannot establish identification.
