35,595 results · Most relevant
Attack acceleration first when working on sprint technique, because in most sports the max speed phase won't express much difference. Unless you're a winger getting big open breaks covering 40-50 meters, max speed matters less. Getting good at acceleration is the low-hanging fruit and big bang for your buck for most athletes.
An ordered deployment workflow: update the application manifest to concatenate tasks so 'spin build' compiles, composes, and builds the MCP server within the Spin developer experience; run 'spin akamai deploy', which composes the server, asks for a name, and interacts with the service registry; the Wasm file and manifest are turned into OCI layers and uploaded; every service region must confirm receipt and capability, the workload is instantiated once, and an internal health check runs; once all regions return HTTP 200, a generic subdomain is rolled so the MCP server is on the public internet. The demo achieved global distribution in roughly 60 seconds.
A demonstrated end-to-end workflow: install WASMCP from github.com/wasmcp/wasmcp, scaffold with 'wasmcp new' (Rust, TypeScript, or Python templates), npm install, define tool schemas in an array with precise descriptions for humans and LLMs, implement a call-tool dispatcher that validates incoming arguments, compile with 'make' to tools.wasm, compose with 'wasmcp compose', test locally via 'npx @modelcontextprotocol/inspector' against localhost:3000, then deploy with 'spin build' combined with 'spin akamai deploy' (allowing terminal access to the service registry).
live-demo walkthrough; exact commands as shown on screen
A demonstrated agent workflow: create a new Spin app from a TypeScript template, bring in Vercel AI SDK dependencies, point the agent at an Ollama LLM running on a Linode instance with a dedicated GPU, define the agent's tools in the Spin app configuration, give it an identity and intent instruction, register tools with step-count constraints, generate and return the response in the HTTP handler, then deploy with 'spin aka deploy' and point clients at the agent.
live-demo walkthrough; LLM-on-Linode detail is the host's own setup
Commercial context: The creator presents this as their own offering and directs viewers to get it.
A locally coherent, ordered workflow demonstrated in the talk: install WASMCP from github.com/wasmcp/wasmcp to get a CLI; scaffold a new MCP server with 'wasmcp new' choosing Rust, TypeScript, or Python and a template; run 'npm install' for the TypeScript project; express the input schema and list tools in a simple array with precise descriptions so humans and LLMs know how to handle them (the example tool validates arguments and returns concatenated input); compile with 'make' to produce a tools WebAssembly component; run 'wasmcp compose' to pull all necessary components and compose a full-fledged MCP server (authentication was skipped for the demo); run it locally with 'spin up -f server.wasm' on localhost:3000; verify with 'npx @modelcontextprotocol/inspector' by connecting and listing.
Patterson recommends pre-configuring cloud environments so agents can start developing immediately without downloading dependencies from potentially contaminated registries. When an agent is put on a fresh box and told to run a project, it will read the contents and start downloading things from unknown sources — and any registry it grabs from could be contaminated.
The speaker advises writing a custom agent if you have a specific task, review, compliance, or regulatory requirement that needs custom tools or checks. When building custom agents, you can control which model the agent uses and the instructions you give it.
Dominik Kundel recommends CodexExec, which spins up a non-interactive interface for kicking off tasks to Codex, as great for scripting — for example scripting acts like auto-fixing a PR in a CI-CD implementation.
Dominik Kundel strongly recommends exposing new functions as part of your interface so the agent can control itself within the Codex thread — like spinning up automations — but marking them as deferred so you don't pollute the context window with extra functions; deferred tools stay available to the agent without confusing it.
Pedro Lopez recommends that agent-facing CLIs accept JSON input and return JSON output, since agents construct complex queries more directly with JSON than with flags, and JSON output enables Unix pipes like JQ.
Pedro Lopez says skills are a must when shipping CLIs: without a skill an agent may not know the CLI exists, and a surfaced description helps agents use the tool effectively.
Pedro Lopez explains Airbyte keeps tool counts small after trial and error: for connector execution, only two main tools — one to describe the connector (schema of how to query) and one to execute (read, write, delete records). Exposing a tool per entity and action would explode the count; instead use progressive discovery of connector capabilities and limit context in tool descriptions, which really helps MCP server performance.
Pedro Lopez recommends OAuth as the way to authenticate the MCP server itself: a connect button spins up the OAuth flow where the user signs in, accepts privileges, and gets set up with linked connectors. Bearer auth or other non-OAuth mechanisms will be hard because the spec is heavy on OAuth and main clients lean toward OAuth for better install UX — Anthropic's custom connector registration has no way to input a bearer token.
The engineering curriculum starts with basics (creating skills, using MCPs, spec-driven development, responsible and mindful AI use), progresses to deeper topics (creating MCPs for new functionality, the hook system of Codex and Claude, extending the harness, autonomous agents running routines in the background), and ends on applied topics such as applied WordPress AI and building a personal assistant. The goal is to walk people from foundations to creating new things themselves.
Matt Gibiec recommends pausing to understand what the team is really trying to accomplish and how to measure the success of their agents before scaling up, noting teams jumped into the AI era quickly and often lack instructions for measuring agent value.
Abhi Arya recommends designing so that when the agent is confidently wrong, someone finds out and finds out fast — that is what makes people trust it with real work. He adds that if you only focus on what the agent connects to (connectors), you miss the real question of who finds out when the agent is confidently wrong and how fast.
Abhi Arya recommends building for the interface where the human is right there to verify, because that is where agent mistakes are cheapest and the agent is most powerful — build the pipeline, generate the schema, and pull in the right context there. By building for that interface, user satisfaction with the MCP went up because they can see what is going on.
Building for agent experience means considering the agent being in the loop with the people who have to answer for the work downstream. The key question isn't just what the agent connects to — everyone's agent connects to everything nowadays. Ask: when your agent is confidently wrong, who finds out and how fast do they find out? If you build for fast detection of confident errors, you can build something people will actually trust with real work.
To avoid auto mode, don't hand your agent an API — hand it tools that carry the overall expertise, such as the right patterns, the state, and the validators. Design tools so the correct path becomes the simplest path that the MCP can take.
Dr. Elissa Epel advises listeners to step back and ask themselves whether they have a situation in their life that is unwanted and cannot be changed, and to honestly assess how much time they spend thinking about it. This self-audit is framed as the first step toward recognizing chronic stress patterns.
Choose sources → to get a library of your own and a daily brief.