35,866 results · Most relevant
Reviewers become the bottleneck if you don't use AI as a first-pass reviewer before human review. Human reviewers typically won't look at a PR until CI is green, so CI failures also slow the review process by preventing parallel review.
Dr. Andy Galpin argues that failing to apply progressive overload is the number one mistake people make outside of not training at all, because without it adaptation stops.
Dr. Andy Galpin explains that as long as the intention to contract hard is present, the amount of load on the bar can be reduced — even to zero — and strength work still counts. He uses the plank as an example: the same position can be held with minimal contraction or with maximal contraction (pulling scapula down and back, squeezing core, quads, and glutes), and the maximal-effort version still contributes to strength production even though the external load is unchanged. He adds that large strength improvements are theoretically possible at 50% of one's max if contracting as hard as possible.
moderate
The biggest aging problem to solve is preserving muscle power and strength rather than muscle size. Functionality — standing up, moving, catching yourself from a fall, and feeling confident in movement — is a function of muscle power more than muscle size, and power is highly correlated with living unassisted as you age.
A typographic scale is a way of setting constraints so you have fewer options when choosing and working with type. When building and scaling a brand or a system used by multiple people, refine down font choices instead of leaving every size as an option.
For robotics, the most important thing is the ability to predict the future: any physical system is fundamentally about, based on present and past information, what should you do next. The robot is just a part of the world — it influences the world and the world influences how it should behave. Today's instantiation of that belief is the world action model.
A hierarchical agentic system around the world action model allows the robot to compose different capabilities and skills for longer-horizon tasks. Learning high-level decision-making with a low-level action-outputting model would be extremely inefficient. Human decision-making involves thinking in steps of a recipe and interleaving tasks while waiting — e.g., when the washer finishes, the robot should immediately move towels to the dryer to avoid becoming a workflow bottleneck.
Unlike language models, robotics has no internet-scale corpus, so every company building models or hardware must think about data. No single company's self-collected data is sufficient — like trying to build an internet with only Reddit or only Facebook — so acquisition must extend beyond self-collection: buying data and using data that already exists, across many tiers.
None noted.
Egocentric data of humans doing tasks is the most important robotics data: its diversity covers nearly every physical activity and gives a strong prior on how the world evolves around an embodied actor. But until robots look exactly like humans there is a gap between human and robot actions, so human data alone won't let robots execute directly. Robot's own data is much more expensive and harder to collect. The recipe: use the largest available data source (egocentric) for a strong prior, then combine with a small amount of robot data to master the target task — human data for cognition coverage, robot data for reflex dexterity — which yields an adaptable, strong model. There is no single winning data strategy.
Presented as Dyna's endorsed recipe, not an independently verified result.
The robotics problem should be thought of as a system problem — good agent, good harness engineer, good model, good hardware — not just a modeling problem.
none stated
The robotics problem should be treated as a system problem — needing good agents, harness engineers, models, and hardware — not just a modeling problem. Dyna wants a general harness layer for robotics foundation models, currently wrapping their own model, and will eventually have its own SDK for wrapping the model into an agentic harness.
Jason Ma frames the robotics bitter lesson: scaling will work, but in robotics there is no internet — you must first get hardware and sensor choices right, then scale the right data. With the right sensor set, scaling robot data yields predictable returns on model performance — robotics is not fundamentally different from other ML domains. He also advises avoiding baking task-specific priors into robot perception (e.g., drawing bounding boxes so robots 'see objects as they are') — keep the algorithm simple and scale the right data so generalization emerges.
The bitter lesson in robotics is to keep the algorithm simpler and scale the right kind of data so generalization and better behavior emerge; it also tells you to remove human biases and take the most raw representation — camera inputs — and predict all of it. Robotics will scale just like any other domain machine learning has solved, but how to scale is much harder because there is no internet: you have to get your hardware and sensors right first.
Jason Ma recommends combining egocentric human data (for broad physical priors and robot cognition) with a small amount of the robot's own data (for low-level reflex dexterity) in one model, rather than betting on a single data type. He explains there is a gap between human actions and robot actions: training only on human data won't let a robot execute actions directly until the robot physically resembles a human, so robot-collected data is still needed for adaptation. Robot-collected data is much more expensive and harder to gather than human data, which is why the recipe is large-scale human data plus a small amount of robot data.
Jason Ma argues data is the most important thing in robotics today because, unlike language models, there is no internet. He recommends prioritizing egocentric human data as the top data source for robot pre-training, because human data is so diverse it covers every physical activity and gives the model a strong prior on how the world evolves around an embodied actor. He also recommends designing robot proportions to match real human measurements when pre-training on human data, to maximize transfer — Dyna's robot is measured against real people for this reason.
To build a general-purpose robot, Jason Ma recommends first training a strong general base model on as much data as possible, then adapting to specific tasks with minimal fine-tuning — mirroring how humans have broad base knowledge plus task-specific training. He notes that a few dozen minutes of task data (e.g., 45 minutes) is enough to adapt a strong general robot foundation model to a new task like pulling drinks from a fridge, and that learning a new robot task requires only a couple of hours of robot data, in some tasks just tens of minutes (the chopping task took 45 minutes).
Long real-world tasks require high-level decision-making beyond continuous action trajectories. A hierarchical system — an agentic harness around the world action model — lets the model compose capabilities and skills for much longer horizon tasks. In theory a low-level action model could learn this reasoning itself, but it would be extremely inefficient.
none stated
The best way to build a human-like robot is an iterative approach: robotics is so hard and the stack is so long that it's hard to know a priori what the right decision is. Iterating with a semi-humanoid form factor and deploying to real customers creates a feedback loop you wouldn't get spending 5-10 years building a warehouse humanoid, and this iterative approach will get us closer to the final robot faster.
For robotics, the most important thing is the ability to predict the future — based on present and past information, what should you do next. A physical system is fundamentally about predicting what comes next. Predicting robot actions is predicting what the robot should do next, but the robot is just part of the world: the robot influences the world, and the world also influences how the robot should behave.
none stated
Steve Jamison argues that looking at AI spend (60x) and output (43%) in isolation hides the tradeoff; putting salary into the equation and taking the ratio of cost to throughput gives the answer. He frames AI spend per PR as the intelligence you're buying to make devs go faster, and PRs per engineer as what you're getting for that spend.
possible_numeric_error
Choose sources → to get a library of your own and a daily brief.