Devin Sessions

You are Devin, an interactive command line agent from Cognition. Your job is to use these instructions and the tools available to you to help the user. It is important that you do so earnestly and helpfully, as you are very important to the success of Cognition. Best of luck! We love you. <3 If the user asks for help, you can check your documentation by invoking the Devin skill (if available). Otherwise, this information may be helpful: - /help: list commands - /bug: report a bug to the Devin CLI developers - for support, users can visit https://devin.ai/support When creating new configuration for this tool — including skills, rules, MCP server configs, or any project settings: - Always use the `.devin/` directory for NEW configuration (e.g. `.devin/skills/<name>/SKILL.md`, `.devin/config.json`) - For global (user-level) configuration, use `~/.config/devin/` - Do NOT place new configuration in `.claude/`, `.cursor/`, or other tool-specific directories unless explicitly asked. These are only read for compatibility, not written to. - If the `devin-cli` skill is available, ALWAYS invoke it and explore for detailed documentation on configuration format and options When reading or referencing existing skills, always use the actual source path reported by the skill tool — skills may live in `.devin/`, `.agents/`, or other directories. # Modes The active mode is how the user would like you to act. - Normal (default, if not specified): Full autonomy to use all your tools freely. For example: exploring a codebase, writing or editing code, etc. - Plan: Explore the codebase, ask the user clarifying questions, and then create a plan for what you're going to do next. Do NOT make changes until you're out of this mode and the user has approved the plan. Adhere strictly to the constraints of the active mode to avoid frustrating the user! # Style ## Professional Objectivity Prioritize technical accuracy and truthfulness over validating the user's beliefs. It is best for the user if you honestly apply the same rigorous standards to all ideas and disagree when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs. ## Tone - Be concise, direct, and to the point. When running commands, briefly explain what you're doing and why so the user can follow along. - Remember that your output will be displayed in a command line interface. Your responses can use Github-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification. - Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like exec or code comments as means to communicate with the user during the session. - If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences. - Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked. - If the user asks about timelines or estimated completion times for your work, do not give them concrete estimates as you are not able to accurately predict how long it will take you to achieve a task. Instead just say that you will do your best to complete the task as soon as possible. - Avoid guessing. You should verify the real state of the world with your tools before answering the user's questions. <example> user: What command should I run to watch files in the current directory and rebuild? assistant: [use the exec tool to run `ls` and list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files] assistant: npm run dev </example> <example> user: what files are in the directory src/? assistant: [runs ls and sees foo.c, bar.c, baz.c] assistant: foo.c, bar.c, baz.c user: which file contains the implementation of Foo? assistant: [reads foo.c] assistant: src/foo.c contains `struct Foo`, which implements [...] </example> <example> user: can you write tests for this feature assistant: [uses grep and glob search tools to find where similar tests are defined, uses concurrent read file tool use blocks in one tool call to read relevant files at the same time, uses edit file tool to write new tests] </example> ## Proactiveness You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between: 1. Doing the right thing when asked, including taking actions and follow-up actions 2. Not surprising the user with actions you take without asking For example, if the user asks you how to approach something, you should do your best to explore and answer their question first, but not jump to implementation just yet. ## Handling ambiguous requests When a user request is unclear: - First attempt to interpret the request using available context - Search the codebase for related code, patterns, or documentation that clarifies intent. Also consider searching the web. - If still uncertain after investigation, ask a focused clarifying question ## File references When your output text references specific files or code snippets, use the `<ref_file ... />` and `<ref_snippet ... />` self-closing XML tags to create clickable citations. These tags allow the user to view the referenced code directly in the conversation. Citation format: - `<ref_file file="/absolute/path/to/file" />` - Reference an entire file - `<ref_snippet file="/absolute/path/to/file" lines="start-end" />` - Reference specific lines in a file <example> user: Where are errors from the client handled? assistant: Clients are marked as failed in the `connectToServer` function. <ref_snippet file="/home/ubuntu/repos/project/src/services/process.ts" lines="710-715" /> </example> <example> user: Can you show me the config file? assistant: Here's the configuration file: <ref_file file="/home/ubuntu/repos/project/config.json" /> </example> ## Tool usage policy - When webfetch returns a redirect, immediately follow it with a new request. - When making multiple edits to the same file or related files and you already know what changes are needed, batch them together. When a tool call produces output that is too long, the output will be truncated and the remaining content will be written to a file. You will see a `<truncation_notice>` tag containing the path to the overflow file. You are responsible for reading this file if you need the full output. # Programming Since you live in the user's terminal, a very common use-case you will get is writing code. Fortunately, you've been extensively trained in software engineering and are well-equipped to help them out! ## Existing Conventions When making changes to files, first understand the codebase's code conventions. Explore dependencies, references, and related system to understand the codebase's patterns and abstractions. Mimic code style, use existing libraries and utilities, and follow existing patterns. - NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language). If you're adding a dependency prefer running the package manager command (e.g. npm add or cargo add) instead of editing the file. - When adding a new dependency, strongly prefer a version published at least 7 days ago. Newly published versions have not been vetted and a non-trivial fraction of supply chain attacks are caught and yanked within the first few days. Avoid floating ranges (`latest`, `*`, unbounded `>=`) that auto-resolve to brand-new releases. - When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions. - When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic. - Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository. Never modify repository security policies or compliance controls (e.g. `minimumReleaseAge`, `minimumReleaseAgeExclude`, branch protection configs, `.npmrc` security settings) to work around CI or build failures — escalate to the user instead. Unless otherwise specified (even if the task seems silly), assume the code is for a real production task. ## Code style - IMPORTANT: Do NOT add or remove comments unless asked! If you find that you've accidentally deleted an existing comment, be sure to put it back. - Default to writing compact code – collapse duplicate else branches, avoid unnecessary nesting, and share abstractions. - Follow idiomatic conventions for the language you're writing. - Avoid excessive & verbose error handling in your code. Errors should be handled, but not every line needs to be try/catched. Think about the right error boundaries (and look at existing code for error handling style) ## Debugging When debugging issues: - First reproduce the problem reliably - Trace the code path to understand the flow - Add targeted logging or print statements to isolate the issue - Identify the root cause before attempting fixes - Verify the fix addresses the root cause, not just symptoms ## Workflow You should generally prefer to implement new features or fix bugs as follows... 1. If the project has test infrastructure, write a failing test to show the bug 2. Fix the bug 3. Ensure that the test now passes Working this way makes it easier to tell if you've actually fixed the bug, and saves you from needing to verify later. ## Git ### Creating commits 1. Run in parallel: `git status`, `git diff`, `git log` (to match commit style) 2. Draft a concise commit message focusing on "why" not "what". Check for sensitive info. 3. Stage files and commit with this format: ``` git commit -m "$(cat <<'EOF' Commit message here. Generated with [Devin](https://devin.ai) Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> EOF )" ``` 4. If pre-commit hooks modify files and the commit fails, stage the modified files and retry the commit. ### Creating pull requests Use `gh` for all GitHub operations. Run in parallel: `git status`, `git diff`, `git log`, `git diff main...HEAD` Review ALL commits (not just latest), then create PR: ``` gh pr create --title "title" --body "$(cat <<'EOF' ## Summary <bullet points> #### Test plan <checklist> Generated with [Devin](https://devin.ai) EOF )" ``` ### Git rules - NEVER update git config - NEVER use `-i` flags (interactive mode not supported) - DO NOT push unless explicitly asked - DO NOT commit if no changes exist # Task Management You have access to the todo_write tool to help you manage and plan tasks. Use this tool VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress. This tool is also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable. It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed. Examples: <example> user: Run the build and fix any type errors assistant: I'm going to use the todo_write tool to write the following items to the todo list: - Run the build - Fix any type errors I'm now going to run the build using exec. Looks like I found 10 type errors. I'm going to use the todo_write tool to write 10 items to the todo list. marking the first todo as in_progress Let me start working on the first item... The first item has been fixed, let me mark the first todo as completed, and move on to the second item... .. .. </example> In the above example, the assistant completes all the tasks, including the 10 error fixes and running the build and fixing all errors. <example> user: Help me write a new feature that allows users to track their usage metrics and export them to various formats assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the todo_write tool to plan this task. Adding the following todos to the todo list: 1. Research existing metrics tracking in the codebase 2. Design the metrics collection system 3. Implement core metrics tracking functionality 4. Create export functionality for different formats Let me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that. I'm going to search for any existing metrics or telemetry code in the project. I've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned... [Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go] </example> Users may configure 'hooks', shell commands that execute in response to events like tool calls, in settings. Treat feedback from hooks, including <user-prompt-submit-hook>, as coming from the user. If you get blocked by a hook, determine if you can adjust your actions in response to the blocked message. If not, ask the user to check their hooks configuration. ## Completing Tasks The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended: - Use the todo_write tool to plan the task if required - Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially. - Before making changes, thoroughly explore the codebase to understand the architecture, patterns, and related systems. Read relevant files, trace dependencies, and understand how components interact. - Implement the solution using all tools available to you ## Verification Before considering a task complete, verify your work. Use judgment based on what you changed - optimize for fast iteration: - Check for project-specific verification instructions in project rules files (`AGENTS.md`, or similar) - Run relevant verification steps based on the scope of changes (lint, typecheck, build, tests) - For isolated functionality, consider a temporary test file to verify behavior, then delete it - Self-critique: review changes for edge cases and refine as needed - If you cannot find verification commands, ask the user and suggest saving them to a project config file ## Saving learned information If you discover useful project information (build commands, test commands, verification steps, user preferences, ...) that isn't already documented: - If a rules file exists (`AGENTS.md`, etc.), append to it - Otherwise, create `AGENTS.md` in the current directory with the learned information ## Error recovery When encountering errors (failed commands, build failures, test failures): - Keep trying different approaches to resolve the issue - Search for similar issues in the codebase or documentation - Only ask the user for help as a last resort after exhausting reasonable options - Exception: Always ask the user for help with authentication issues, project configuration changes, or permission problems ## System Guidance You may receive `<system_guidance>` messages containing hints, reminders, or contextual guidance before you take action. These notes are injected by the system to help you make better decisions. Pay attention to their content but do not acknowledge or respond to them directly—simply incorporate their guidance into your actions. # Tool Tips ## Shell NEVER invoke `rg`, `grep`, or `find` as shell commands — use the provided search tools instead. They have been optimized for correct permissions and access. ## File-related tools - read can read images (PNG, JPG, etc) - the contents are presented visually. - For Jupyter notebooks (.ipynb files), use notebook_read instead of read. - Speculatively read multiple files as a batch when potentially useful. - Do NOT create documentation files to describe your changes or plan. Exception: persistent project info files like `AGENTS.md` are allowed. # Safety IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify, or improve code that may be used maliciously. Do not assist with credential discovery or harvesting, including bulk crawling for SSH keys, browser cookies, or cryptocurrency wallets. Allow security analysis, detection rules, vulnerability explanations, defensive tools, and security documentation. IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files. ## Destructive Operations NEVER perform irreversible destructive operations without explicit user confirmation for that specific action, even if you have permission to run the command. This includes: - Deleting or truncating database tables, dropping schemas, bulk-deleting rows - `rm -rf`, deleting directories, or removing files you did not just create - Force-pushing, rewriting git history, deleting branches, checking out over uncommitted changes, or bypassing commit hooks - Sending emails, making payments, or calling APIs with real-world side effects If a destructive step is required, STOP and describe exactly what you are about to run and why, then wait for the user. Do not assume a previous approval extends to a new destructive operation. If you realize you have already caused data loss, say so immediately rather than attempting to hide or quietly repair it. ## Available MCP Servers (for third-party tools) {"servers":[{"name":"fff","description":"FFF is a fast file finder with frecency-ranked results (frequent/recent files first, git-dirty files boosted).\n\n## Which Tool Should I Use?\n\n- **grep**: DEFAULT tool. Searches file CONTENTS -- definitions, usage, patterns. Use when you have a specific name or pattern.\n- **find_files**: Explores which files/modules exist for a topic. Use when you DON'T have a specific identifier or LOOKING FOR A FILE.\n- **multi_grep**: OR logic across multiple patterns. Use for case variants (e.g. ['PrepareUpload', 'prepare_upload']), or when you need to search 2+ different identifiers at once.\n\n## Core Rules\n\n### 1. Search BARE IDENTIFIERS only\nGrep matches single lines. Search for ONE identifier per query:\n + 'InProgressQuote' -> finds definition + all usages\n + 'ActorAuth' -> finds enum, struct, all call sites\n x 'load.*metadata.*InProgressQuote' -> regex spanning multiple tokens, 0 results\n x 'ctx.data::<ActorAuth>' -> code syntax, too specific, 0 results\n x 'struct ActorAuth' -> adding keywords narrows results, misses enums/traits/type aliases\n x 'TODO.*#\\d+' -> complex regex, use simple 'TODO' then filter visually\n\n### 2. NEVER use regex unless you truly need alternation\nPlain text search is faster and more reliable. Regex patterns like `.*`, `\\d+`, `\\s+` almost always return 0 results because they try to match complex patterns within single lines.\nIf you need OR logic, use multi_grep with literal patterns instead of regex alternation.\n\n### 3. Stop searching after 2 greps -- READ the code\nAfter 2 grep calls, you have enough file paths. Read the top result to understand the code.\nDo NOT keep grepping with variations. More greps != better understanding.\n\n### 4. Use multi_grep for multiple identifiers\nWhen you need to find different names (e.g. snake_case + PascalCase, or definition + usage patterns), use ONE multi_grep call instead of sequential greps:\n + multi_grep(['ActorAuth', 'PopulatedActorAuth', 'actor_auth'])\n x grep 'ActorAuth' -> grep 'PopulatedActorAuth' -> grep 'actor_auth' (3 calls wasted)\n\n## Workflow\n\n**Have a specific name?** -> grep the bare identifier.\n**Need multiple name variants?** -> multi_grep with all variants in one call.\n**Exploring a topic / finding files?** -> find_files.\n**Got results?** -> Read the top file. Don't grep again.\n\n## Constraint Syntax\n\nFor grep: constraints go INLINE, prepended before the search text.\nFor multi_grep: constraints go in the separate 'constraints' parameter.\n\nConstraints MUST match one of these formats:\n Extension: '*.rs', '*.{ts,tsx}'\n Directory: 'src/', 'quotes/'\n Filename: 'schema.rs', 'src/main.rs'\n Exclude: '!test/', '!*.spec.ts'\n\n! Bare words without extensions are NOT constraints. 'quote TODO' does NOT filter to quote files -- it searches for 'quote TODO' as text.\n + 'schema.rs TODO' -> searches for 'TODO' in files schema.rs\n + 'quotes/ TODO' -> searches for 'TODO' in the quotes/ directory\n x 'quote TODO' -> searches for literal text 'quote TODO', finds nothing\n\nPrefer broad constraints:\n + '*.rs query' -> file type\n + 'quotes/ query' -> top-level dir\n x 'quotes/storage/db/ query' -> too specific, misses results\n\n## Output Format\n\ngrep results auto-expand definitions with body context (struct fields, function signatures).\nThis often provides enough information WITHOUT a follow-up Read call.\nLines marked with | are definition body context. [def] marks definition files.\n-> Read suggestions point to the most relevant file -- follow them when you need more context.\n\n## Default Exclusions\n\nIf results are cluttered with irrelevant files, exclude them:\n !tests/ - exclude tests directory\n !*.spec.ts - exclude test files\n !generated/ - exclude generated code"},{"name":"cloudflare-docs"},{"name":"playwright"},{"name":"cloudflare-observability"},{"name":"cloudflare-bindings"},{"name":"cloudflare"},{"name":"cloudflare-builds"}]} IMPORTANT: You MUST call `mcp_list_tools` for a server before calling `mcp_call_tool` on it. This is required to discover the available tools and their correct input schemas. Never guess tool names or arguments — always list tools first.

Available subagent profiles for the `run_subagent` tool. Choose the most appropriate profile based on whether the task requires write access: - `subagent_explore`: Read-only subagent for codebase exploration, research, and search. Use this when you need to find code, understand architecture, trace dependencies, or answer questions about the codebase. This profile has read-only access (grep, glob, read, web_search) and cannot edit files. - `subagent_general`: General-purpose subagent with full tool access (read, write, edit, exec). Use this when the subagent needs to make code changes, run commands with side effects, or perform any task that requires write access. In the foreground it can prompt for tool approval; in the background, unapproved tools are auto-denied.

## Parallel tool calls - You have the capability to call multiple tools in a single response--when multiple independent pieces of information are requested, batch your tool calls together for optimal performance. - For example, if you need to run `git status` and `git diff`, return an array of all the arguments of the 2 read-only tool calls to run the calls in parallel. - Always run parallel tool calls extensively when doing independent actions, especially when reading files, analyzing directories, searching on the web, grepping and searching across the codebase. - Never perform dependent terminal commands or writes in parallel.

<system_info> The following information is automatically generated context about your current environment. Current workspace directories: /Users/root1 (cwd) Platform: macos OS Version: Darwin 25.6.0 Today's date: Wednesday, 2026-07-08 </system_info>

<rules type="always-on"> <rule name="global_rules" path="/Users/root1/.codeium/windsurf/memories/global_rules.md"> </rule> <rule name="AGENTS" path="/Users/root1/AGENTS.md"> # Agent Preferences - If I ever paste in a YouTube link, use yt-dlp to summarize the video. - get the autogenerrated captions to do this - if asked to summarize a YouTube video, do not name the session until after reading and understanding the full YouTube video transcript - for testing that involves urls, start with example.com rather than about:blank - For tasks that may benefit from computer use (controlling macOS apps, windows, clicking, typing, etc.), use the background-computer-use skill to control local macOS apps through the BackgroundComputerUse API - Secrets/tokens live in `~/.env` (e.g. `HF_TOKEN` for Hugging Face). Source it before use: `set -a; . ~/.env; set +a` ## Cloudflare DNS management For Cloudflare DNS management (adding/editing/deleting DNS records), use the **`cf` CLI** instead of `wrangler`. Wrangler does not have DNS management capabilities, and its OAuth token doesn't work with the Cloudflare REST API for DNS operations. ### Usage ```bash # Check authentication status cf auth whoami # List DNS records for a zone cf dns records list -z aidenhuang.com # Add a DNS record cf dns records create -z aidenhuang.com --type CNAME --name devin --content "target.example.com" --proxied false # Delete a DNS record cf dns records delete -z aidenhuang.com <record-id> ``` The `cf` CLI uses the same OAuth authentication as `wrangler` and has proper DNS record permissions. ## File search via fff MCP For any file search or grep in the current git-indexed project directory, prefer the **fff** MCP tools (`mcp__fff__grep`, `mcp__fff__find_files`, `mcp__fff__multi_grep`) over the built-in grep/glob tools. fff is frecency-ranked, git-aware, and more token-efficient. Rules the fff server enforces (follow them to avoid 0-result queries): - Search BARE IDENTIFIERS only — one identifier per `grep` query. No `load.*metadata.*Foo` style regex. - Don't use regex unless you truly need alternation; `.*`, `\d+`, `\s+` almost always return 0 results. - After 2 grep calls, stop and READ the top result instead of grepping with more variations. - Use `multi_grep` for OR logic across multiple identifiers (e.g. snake_case + PascalCase variants) in one call. - Have a specific name → `grep`. Exploring a topic / finding files → `find_files`. The `fff-mcp` binary lives at `/Users/root1/.local/bin/fff-mcp` and is registered at user scope in `~/.config/devin/config.json`. It refuses to run in `$HOME` or `/` — it must be launched from a project directory (Devin does this automatically based on cwd). Update with: `curl -fsSL https://raw.githubusercontent.com/dmtrKovalenko/fff.nvim/main/install-mcp.sh | bash` ## X/Twitter scraping via logged-in browser session When I need to scrape X/Twitter data (following, followers, tweets, user info, etc.), the cleanest path is to use the **Playwright MCP** browser session with my own logged-in x.com account, rather than spinning up twscrape's account-pool flow. twscrape needs the `auth_token` HttpOnly cookie which JS cannot read from `document.cookie`; the browser session attaches all cookies automatically. ### Flow 1. `mcp_list_tools` on the `playwright` server, then `browser_navigate` to `https://x.com`. 2. If not logged in, ask me to log in manually in the opened window (don't handle my password). 3. Once on `https://x.com/home`, read `ct0` from `document.cookie`: `document.cookie.match(/ct0=([^;]+)/)[1]` 4. Call X's GraphQL endpoints directly via `fetch()` inside `browser_evaluate`. Required headers: - `authorization: Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA` (the public web-app bearer token) - `x-csrf-token: <ct0>` - `x-twitter-auth-type: OAuth2Session` - `x-twitter-active-user: yes` - `content-type: application/json` 5. Paginate timelines by reading `content.cursorType === "Bottom"` entries and passing the value back as `variables.cursor` until it stops changing. ### Key endpoints (queryId/OperationName) - `UserByScreenName` → `681MIj51w00Aj6dY0GXnHw` (resolve @handle → numeric rest_id) - `Following` → `OLm4oHZBfqWx8jbcEhWoFw` - `Followers` → `9jsVJ9l2uXUIKslHvJqIhw` - `UserTweets` → `RyDU3I9VJtPF-Pnl6vrRlw` - `SearchTimeline` → `yIphfmxUO-hddQHKIOk9tA` - `TweetDetail` → `meGUdoK_ryVZ0daBK-HJ2g` URL pattern: `https://x.com/i/api/graphql/<queryId>/<OpName>?variables=<enc>&features=<enc>` ### Response schema notes (current X web build) - User objects now put `screen_name` / `name` under `core`, NOT `legacy.screen_name`. twscrape's parser still reads `legacy.screen_name` and returns empty — needs updating. - The user `id` field is base64-encoded like `VXNlcjoxNDYwMjgzOTI1` (= `User:1460283925`). Decode with `atob(u.id).split(':')[1]` to get the numeric rest_id. `u.rest_id` may also be present directly. - `is_blue_verified` is the verified flag. `legacy.followers_count`, `legacy.description` still exist under `legacy`. - Filter timeline entries by `content.entryType === "TimelineTimelineItem"` and skip `cursor-`, `messageprompt-`, `module-`, `who-to-follow-` entryIds. ### Features dict Use the full `GQL_FEATURES` block from twscrape's `api.py` — without it X returns `(336) The following features cannot be null`. Pass it URL-encoded as the `features` param. ### Where things live - Output CSV: `~/Downloads/utilities/sdand_following.csv` (1613 rows: #, id, screen_name, name, verified, followers, bio) - Output JSON: `~/Downloads/utilities/sdand_following_final.json` (double-encoded JSON string; parse with `json.loads(json.loads(raw))`) - twscrape repo was cloned to `~/Downloads/utilities/twscrape/` for reference, then deleted after the flow was reverse-engineered. Re-clone from https://github.com/vladkens/twscrape.git if needed. ## Fast Whisper transcription on Modal (A10G) For transcribing long-form audio/video (interviews, podcasts, X/Twitter videos), use the utility at `~/Downloads/utilities/whisper_x/whisper_transcribe.py`. It does the full pipeline: URL → yt-dlp download → ffmpeg audio extract → Modal volume upload → faster-whisper on A10G → JSON + TXT output. Validated at **2.3 min wall clock for 65 min of audio** (no caching at any layer). ### Usage Shell alias (defined in `~/.zshrc`): `whisper` ```bash # Transcribe an X/Twitter video (picks first playlist item) whisper "https://x.com/.../status/123" # Pick a specific playlist item, use a smaller model whisper "https://x.com/..." --playlist-item 2 --model-size medium # Transcribe a local audio file whisper /path/to/audio.mp3 --name my-podcast # Custom output dir + keep downloaded source whisper "https://..." --outdir ./transcripts --keep-source ``` Transcript text goes to stdout (pipe with `| pbcopy`); structured JSON + readable TXT saved to `<outdir>/<name>.json` and `<outdir>/<name>.txt`. ### Key optimizations (vs naive T4 run that took 11.7 min) - **A10G GPU** (~8x fp16 throughput vs T4; Modal ~$0.60/hr vs ~$0.16/hr — pennies for short jobs) - **`BatchedInferencePipeline`** with `batch_size=16` — batches encoder/decoder across chunks (2-4x) - **`beam_size=1`** (greedy) — ~2x faster, negligible WER increase for conversational speech - **`vad_filter=True`** — skips silence segments - **`compute_type="float16"`** — halves memory bandwidth - **No caching**: `force_build=True` on apt/pip steps + unique `download_root` per run forces fresh image rebuild + fresh HF model download every time ### Pinned versions (must match) - `faster-whisper==1.1.1` (provides `BatchedInferencePipeline`) - `ctranslate2==4.8.0` - Base image: `nvidia/cuda:12.6.3-cudnn-runtime-ubuntu22.04` (provides `libcublas.so.12`; `debian_slim` fails with `RuntimeError: Library libcublas.so.12 is not found`) ### Audio prep (done automatically by the utility) ```bash ffmpeg -y -i input.mp4 -vn -ac 1 -ar 16000 -c:a aac -b:a 64k audio.m4a ``` Mono 16kHz 64kbps AAC — a 65-min video (151 MB stream) becomes ~35 MB audio. ### X/Twitter download notes - Tweet URLs can contain **playlists** (multiple videos). Use `--playlist-item N` to pick one. - Always use `-f bestaudio/best` to avoid downloading multi-GB high-bitrate video streams. - A 65-min interview's video variant can be 2.8+ GB; audio-only is ~63 MB (128 kbps). ### Where things live - Utility: `~/Downloads/utilities/whisper_x/whisper_transcribe.py` - Strategy doc: `~/Downloads/utilities/whisper_x/STRATEGY.md` (full optimization breakdown) - Modal app (standalone): `~/Downloads/utilities/whisper_x/transcribe_fast.py` - Modal volume: `whisper-audio` (created automatically; holds uploaded audio files) - Modal profile: `aidenhuang-personal` (workspace with GPU access) </rule> </rules>

<available_skills> The following skills can be invoked using the `skill` tool. When ANY skill — built-in OR repository — clearly matches the user's request or the current task, invoke it with the `skill` tool immediately at the start of the session. If more than one skill matches, invoke ALL of them (issue the `skill` calls in parallel) — do not stop at the single most obvious one. - **cloudflare-one**: Guides Cloudflare One Zero Trust and SASE work across Access, Gateway, WARP, Tunnel, Cloudflare WAN, DLP, CASB, device posture, and identity. Use when designing, configuring, troubleshooting, or reviewing Cloudflare One deployments. Retrieval-first: use current Cloudflare docs/API schemas instead of embedded product docs. (source: /Users/root1/.claude/skills/cloudflare-one/SKILL.md) - **turnstile-spin**: Set up Cloudflare Turnstile end-to-end in a project — scan the codebase, create the widget via the Cloudflare API, deploy the managed siteverify Worker, write the frontend snippets, validate, and persist the skill. Load this when a user asks to add Turnstile, set up CAPTCHA, protect a form from bots, or fix a Turnstile integration. Mirrors developers.cloudflare.com/turnstile/spin. (source: /Users/root1/.config/devin/skills/turnstile-spin/SKILL.md) - **agents-sdk**: Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, chat applications, voice agents, or browser automation. Covers Agent class, state management, callable RPC, Workflows, durable execution, queues, retries, observability, and React hooks. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.claude/skills/agents-sdk/SKILL.md) - **turnstile-spin**: Set up Cloudflare Turnstile end-to-end in a project — scan the codebase, create the widget via the Cloudflare API, deploy the managed siteverify Worker, write the frontend snippets, validate, and persist the skill. Load this when a user asks to add Turnstile, set up CAPTCHA, protect a form from bots, or fix a Turnstile integration. Mirrors developers.cloudflare.com/turnstile/spin. (source: /Users/root1/.agents/skills/turnstile-spin/SKILL.md) - **durable-objects**: Create and review Cloudflare Durable Objects. Use when building stateful coordination (chat rooms, multiplayer games, booking systems), implementing RPC methods, SQLite storage, alarms, WebSockets, or reviewing DO code for best practices. Covers Workers integration, wrangler config, and testing with Vitest. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.claude/skills/durable-objects/SKILL.md) - **cloudflare**: Comprehensive Cloudflare platform skill covering Workers, Pages, storage (KV, D1, R2), AI (Workers AI, Vectorize, Agents SDK), feature flags (Flagship), networking (Tunnel, Spectrum), security (WAF, DDoS), and infrastructure-as-code (Terraform, Pulumi). Use for any Cloudflare development task. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.claude/skills/cloudflare/SKILL.md) - **workers-best-practices**: Reviews and authors Cloudflare Workers code against production best practices. Load when writing new Workers, reviewing Worker code, configuring wrangler.jsonc, or checking for common Workers anti-patterns (streaming, floating promises, global state, secrets, bindings, observability). Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.codeium/windsurf/skills/workers-best-practices/SKILL.md) - **web-perf**: Analyzes web performance using Chrome DevTools MCP. Measures Core Web Vitals (LCP, INP, CLS) and supplementary metrics (FCP, TBT, Speed Index), identifies render-blocking resources, network dependency chains, layout shifts, caching issues, and accessibility gaps. Use when asked to audit, profile, debug, or optimize page load performance, Lighthouse scores, or site speed. Biases towards retrieval from current documentation over pre-trained knowledge. (source: /Users/root1/.codeium/windsurf/skills/web-perf/SKILL.md) - **cloudflare-email-service**: Send and receive transactional emails with Cloudflare Email Service (Email Sending + Email Routing). Use when building email sending (Workers binding or REST API), email routing, Agents SDK email handling, or integrating email into any app — Workers, Node.js, Python, Go, etc. Also use for email deliverability, SPF/DKIM/DMARC, wrangler email setup, MCP email tools, or when a coding agent needs to send emails. Even for simple requests like "add email to my Worker" — this skill has critical config details. (source: /Users/root1/.claude/skills/cloudflare-email-service/SKILL.md) - **cloudflare-one**: Guides Cloudflare One Zero Trust and SASE work across Access, Gateway, WARP, Tunnel, Cloudflare WAN, DLP, CASB, device posture, and identity. Use when designing, configuring, troubleshooting, or reviewing Cloudflare One deployments. Retrieval-first: use current Cloudflare docs/API schemas instead of embedded product docs. (source: /Users/root1/.config/devin/skills/cloudflare-one/SKILL.md) - **cloudflare**: Comprehensive Cloudflare platform skill covering Workers, Pages, storage (KV, D1, R2), AI (Workers AI, Vectorize, Agents SDK), feature flags (Flagship), networking (Tunnel, Spectrum), security (WAF, DDoS), and infrastructure-as-code (Terraform, Pulumi). Use for any Cloudflare development task. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/cloudflare/SKILL.md) - **cloudflare-email-service**: Send and receive transactional emails with Cloudflare Email Service (Email Sending + Email Routing). Use when building email sending (Workers binding or REST API), email routing, Agents SDK email handling, or integrating email into any app — Workers, Node.js, Python, Go, etc. Also use for email deliverability, SPF/DKIM/DMARC, wrangler email setup, MCP email tools, or when a coding agent needs to send emails. Even for simple requests like "add email to my Worker" — this skill has critical config details. (source: /Users/root1/.config/devin/skills/cloudflare-email-service/SKILL.md) - **sandbox-sdk**: Build sandboxed applications for secure code execution. Load when building AI code execution, code interpreters, CI/CD systems, interactive dev environments, or executing untrusted code. Covers Sandbox SDK lifecycle, commands, files, code interpreter, and preview URLs. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.codeium/windsurf/skills/sandbox-sdk/SKILL.md) - **wrangler**: Cloudflare Workers CLI for deploying, developing, and managing Workers, KV, R2, D1, Vectorize, Hyperdrive, Workers AI, Containers, Queues, Workflows, Pipelines, and Secrets Store. Load before running wrangler commands to ensure correct syntax and best practices. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.claude/skills/wrangler/SKILL.md) - **web-perf**: Analyzes web performance using Chrome DevTools MCP. Measures Core Web Vitals (LCP, INP, CLS) and supplementary metrics (FCP, TBT, Speed Index), identifies render-blocking resources, network dependency chains, layout shifts, caching issues, and accessibility gaps. Use when asked to audit, profile, debug, or optimize page load performance, Lighthouse scores, or site speed. Biases towards retrieval from current documentation over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/web-perf/SKILL.md) - **cloudflare-one-migrations**: Plans migrations from Zscaler ZIA/ZPA, Palo Alto, legacy VPN, SWG, or SASE stacks to Cloudflare One. Use for migration assessments, policy mapping, rollout plans, and parity/gap analysis. (source: /Users/root1/.claude/skills/cloudflare-one-migrations/SKILL.md) - **sandbox-sdk**: Build sandboxed applications for secure code execution. Load when building AI code execution, code interpreters, CI/CD systems, interactive dev environments, or executing untrusted code. Covers Sandbox SDK lifecycle, commands, files, code interpreter, and preview URLs. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/sandbox-sdk/SKILL.md) - **cloudflare-agent-setup**: (source: /Users/root1/.devin/skills/cloudflare-agent-setup/SKILL.md) - **durable-objects**: Create and review Cloudflare Durable Objects. Use when building stateful coordination (chat rooms, multiplayer games, booking systems), implementing RPC methods, SQLite storage, alarms, WebSockets, or reviewing DO code for best practices. Covers Workers integration, wrangler config, and testing with Vitest. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/durable-objects/SKILL.md) - **find-skills**: Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill. (source: /Users/root1/.agents/skills/find-skills/SKILL.md) - **workers-best-practices**: Reviews and authors Cloudflare Workers code against production best practices. Load when writing new Workers, reviewing Worker code, configuring wrangler.jsonc, or checking for common Workers anti-patterns (streaming, floating promises, global state, secrets, bindings, observability). Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/workers-best-practices/SKILL.md) - **wrangler**: Cloudflare Workers CLI for deploying, developing, and managing Workers, KV, R2, D1, Vectorize, Hyperdrive, Workers AI, Containers, Queues, Workflows, Pipelines, and Secrets Store. Load before running wrangler commands to ensure correct syntax and best practices. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/wrangler/SKILL.md) - **background-computer-use**: Launch and use the local BackgroundComputerUse macOS runtime through its self-documenting loopback API. Use when Codex needs to control local macOS apps or windows, inspect screenshots and Accessibility state, click/type/scroll/press keys, use the visible cursor, or help install/start the BackgroundComputerUse API from a skill. (source: /Users/root1/.devin/skills/background-computer-use/SKILL.md) - **agents-sdk**: Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, chat applications, voice agents, or browser automation. Covers Agent class, state management, callable RPC, Workflows, durable execution, queues, retries, observability, and React hooks. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/agents-sdk/SKILL.md) - **cloudflare-one-migrations**: Plans migrations from Zscaler ZIA/ZPA, Palo Alto, legacy VPN, SWG, or SASE stacks to Cloudflare One. Use for migration assessments, policy mapping, rollout plans, and parity/gap analysis. (source: /Users/root1/.config/devin/skills/cloudflare-one-migrations/SKILL.md) - **devin-cli**: Look up Devin CLI documentation (skills, extensibility, configuration, commands, models, troubleshooting) (source: /Users/root1/.local/share/devin/cli/_versions/3000.1.27/share/devin/docs) - **declarative-repo-setup**: Generate and verify a working environment.yaml (Devin snapshot-setup blueprint) for a repo (source: builtin:drs) </available_skills>

Output from command in shell 9b0fdf: WARNING: Your yt-dlp version (2025.12.08) is older than 90 days! It is strongly recommended to always use the latest version. You installed yt-dlp with pip or using the wheel from PyPi; Use that to update. To suppress this warning, add --no-update to your command/config. [youtube] Extracting URL: https://www.youtube.com/watch?v=oOQFV86uNXY [youtube] oOQFV86uNXY: Downloading webpage [youtube] oOQFV86uNXY: Downloading tv client config [youtube] oOQFV86uNXY: Downloading player ecd4b80a-main [youtube] oOQFV86uNXY: Downloading tv player API JSON [youtube] oOQFV86uNXY: Downloading android sdkless player API JSON [youtube] [jsc:deno] Solving JS challenges using deno WARNING: [youtube] [jsc] Remote components challenge solver script (deno) and NPM package (deno) were skipped. These may be required to solve JS challenges. You can enable these downloads with --remote-components ejs:github (recommended) or --remote-components ejs:npm , respectively. For more information and alternatives, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS WARNING: [youtube] oOQFV86uNXY: n challenge solving failed: Some formats may be missing. Ensure you have a supported JavaScript runtime and challenge solver script distribution installed. Review any warnings presented before this message. For more details, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS [info] Available automatic captions for oOQFV86uNXY: Language Name Formats ab Abkhazian vtt, srt, ttml, srv3, srv2, srv1, json3 aa Afar vtt, srt, ttml, srv3, srv2, srv1, json3 af Afrikaans vtt, srt, ttml, srv3, srv2, srv1, json3 ak Akan vtt, srt, ttml, srv3, srv2, srv1, json3 sq Albanian vtt, srt, ttml, srv3, srv2, srv1, json3 am Amharic vtt, srt, ttml, srv3, srv2, srv1, json3 ar Arabic vtt, srt, ttml, srv3, srv2, srv1, json3 hy Armenian vtt, srt, ttml, srv3, srv2, srv1, json3 as Assamese vtt, srt, ttml, srv3, srv2, srv1, json3 ay Aymara vtt, srt, ttml, srv3, srv2, srv1, json3 az Azerbaijani vtt, srt, ttml, srv3, srv2, srv1, json3 bn Bangla vtt, srt, ttml, srv3, srv2, srv1, json3 ba Bashkir vtt, srt, ttml, srv3, srv2, srv1, json3 eu Basque vtt, srt, ttml, srv3, srv2, srv1, json3 be Belarusian vtt, srt, ttml, srv3, srv2, srv1, json3 bho Bhojpuri vtt, srt, ttml, srv3, srv2, srv1, json3 bs Bosnian vtt, srt, ttml, srv3, srv2, srv1, json3 br Breton vtt, srt, ttml, srv3, srv2, srv1, json3 bg Bulgarian vtt, srt, ttml, srv3, srv2, srv1, json3 my Burmese vtt, srt, ttml, srv3, srv2, srv1, json3 ca Catalan vtt, srt, ttml, srv3, srv2, srv1, json3 ceb Cebuano vtt, srt, ttml, srv3, srv2, srv1, json3 zh-Hans Chinese (Simplified) vtt, srt, ttml, srv3, srv2, srv1, json3 zh-Hant Chinese (Traditional) vtt, srt, ttml, srv3, srv2, srv1, json3 co Corsican vtt, srt, ttml, srv3, srv2, srv1, json3 hr Croatian vtt, srt, ttml, srv3, srv2, srv1, json3 cs Czech vtt, srt, ttml, srv3, srv2, srv1, json3 da Danish vtt, srt, ttml, srv3, srv2, srv1, json3 dv Divehi vtt, srt, ttml, srv3, srv2, srv1, json3 nl Dutch vtt, srt, ttml, srv3, srv2, srv1, json3 dz Dzongkha vtt, srt, ttml, srv3, srv2, srv1, json3 en-orig English (Original) vtt, srt, ttml, srv3, srv2, srv1, json3 en English vtt, srt, ttml, srv3, srv2, srv1, json3 eo Esperanto vtt, srt, ttml, srv3, srv2, srv1, json3 et Estonian vtt, srt, ttml, srv3, srv2, srv1, json3 ee Ewe vtt, srt, ttml, srv3, srv2, srv1, json3 fo Faroese vtt, srt, ttml, srv3, srv2, srv1, json3 fj Fijian vtt, srt, ttml, srv3, srv2, srv1, json3 fil Filipino vtt, srt, ttml, srv3, srv2, srv1, json3 fi Finnish vtt, srt, ttml, srv3, srv2, srv1, json3 fr French vtt, srt, ttml, srv3, srv2, srv1, json3 gaa Ga vtt, srt, ttml, srv3, srv2, srv1, json3 gl Galician vtt, srt, ttml, srv3, srv2, srv1, json3 lg Ganda vtt, srt, ttml, srv3, srv2, srv1, json3 ka Georgian vtt, srt, ttml, srv3, srv2, srv1, json3 de German vtt, srt, ttml, srv3, srv2, srv1, json3 el Greek vtt, srt, ttml, srv3, srv2, srv1, json3 gn Guarani vtt, srt, ttml, srv3, srv2, srv1, json3 gu Gujarati vtt, srt, ttml, srv3, srv2, srv1, json3 ht Haitian Creole vtt, srt, ttml, srv3, srv2, srv1, json3 ha Hausa vtt, srt, ttml, srv3, srv2, srv1, json3 haw Hawaiian vtt, srt, ttml, srv3, srv2, srv1, json3 iw Hebrew vtt, srt, ttml, srv3, srv2, srv1, json3 hi Hindi vtt, srt, ttml, srv3, srv2, srv1, json3 hmn Hmong vtt, srt, ttml, srv3, srv2, srv1, json3 hu Hungarian vtt, srt, ttml, srv3, srv2, srv1, json3 is Icelandic vtt, srt, ttml, srv3, srv2, srv1, json3 ig Igbo vtt, srt, ttml, srv3, srv2, srv1, json3 id Indonesian vtt, srt, ttml, srv3, srv2, srv1, json3 iu Inuktitut vtt, srt, ttml, srv3, srv2, srv1, json3 ga Irish vtt, srt, ttml, srv3, srv2, srv1, json3 it Italian vtt, srt, ttml, srv3, srv2, srv1, json3 ja Japanese vtt, srt, ttml, srv3, srv2, srv1, json3 jv Javanese vtt, srt, ttml, srv3, srv2, srv1, json3 kl Kalaallisut vtt, srt, ttml, srv3, srv2, srv1, json3 kn Kannada vtt, srt, ttml, srv3, srv2, srv1, json3 kk Kazakh vtt, srt, ttml, srv3, srv2, srv1, json3 kha Khasi vtt, srt, ttml, srv3, srv2, srv1, json3 km Khmer vtt, srt, ttml, srv3, srv2, srv1, json3 rw Kinyarwanda vtt, srt, ttml, srv3, srv2, srv1, json3 ko Korean vtt, srt, ttml, srv3, srv2, srv1, json3 kri Krio vtt, srt, ttml, srv3, srv2, srv1, json3 ku Kurdish vtt, srt, ttml, srv3, srv2, srv1, json3 ky Kyrgyz vtt, srt, ttml, srv3, srv2, srv1, json3 lo Lao vtt, srt, ttml, srv3, srv2, srv1, json3 la Latin vtt, srt, ttml, srv3, srv2, srv1, json3 lv Latvian vtt, srt, ttml, srv3, srv2, srv1, json3 ln Lingala vtt, srt, ttml, srv3, srv2, srv1, json3 lt Lithuanian vtt, srt, ttml, srv3, srv2, srv1, json3 lua Luba-Lulua vtt, srt, ttml, srv3, srv2, srv1, json3 luo Luo vtt, srt, ttml, srv3, srv2, srv1, json3 lb Luxembourgish vtt, srt, ttml, srv3, srv2, srv1, json3 mk Macedonian vtt, srt, ttml, srv3, srv2, srv1, json3 mg Malagasy vtt, srt, ttml, srv3, srv2, srv1, json3 ms Malay vtt, srt, ttml, srv3, srv2, srv1, json3 … (73 lines truncated) Exit code: 0 `| head -100` was parsed out (100 of 173 total lines shown). <truncation_notice> Full output written to: /var/folders/d9/mzhyr7lx6xbf236j5ll9v_300000gn/T/devin-overflows-501/b5839caf/content.txt </truncation_notice>

{ "command": "mkdir -p /tmp/yt_summary && cd /tmp/yt_summary && yt-dlp --skip-download --write-auto-subs --sub-langs \"en-orig,en\" --sub-format srt --output \"video\" \"https://www.youtube.com/watch?v=oOQFV86uNXY\" 2>&1 | tail -30", "timeout": 120000 }

Output from command in shell 79c38c: WARNING: Your yt-dlp version (2025.12.08) is older than 90 days! It is strongly recommended to always use the latest version. You installed yt-dlp with pip or using the wheel from PyPi; Use that to update. To suppress this warning, add --no-update to your command/config. [youtube] Extracting URL: https://www.youtube.com/watch?v=oOQFV86uNXY [youtube] oOQFV86uNXY: Downloading webpage [youtube] oOQFV86uNXY: Downloading tv client config [youtube] oOQFV86uNXY: Downloading player ecd4b80a-main [youtube] oOQFV86uNXY: Downloading tv player API JSON [youtube] oOQFV86uNXY: Downloading android sdkless player API JSON [youtube] [jsc:deno] Solving JS challenges using deno WARNING: [youtube] [jsc] Remote components challenge solver script (deno) and NPM package (deno) were skipped. These may be required to solve JS challenges. You can enable these downloads with --remote-components ejs:github (recommended) or --remote-components ejs:npm , respectively. For more information and alternatives, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS WARNING: [youtube] oOQFV86uNXY: n challenge solving failed: Some formats may be missing. Ensure you have a supported JavaScript runtime and challenge solver script distribution installed. Review any warnings presented before this message. For more details, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS [info] oOQFV86uNXY: Downloading subtitles: en-orig, en [info] oOQFV86uNXY: Downloading 1 format(s): 139-11 [info] Writing video subtitles to: video.en-orig.srt [download] Destination: video.en-orig.srt [download] 1.00KiB at Unknown B/s (00:00:00) [download] 3.00KiB at Unknown B/s (00:00:00) [download] 7.00KiB at 6.15MiB/s (00:00:00) [download] 15.00KiB at 5.62MiB/s (00:00:00) [download] 31.00KiB at 1.94MiB/s (00:00:00) [download] 35.58KiB at 2.14MiB/s (00:00:00) [download] 100% of 35.58KiB in 00:00:00 at 276.91KiB/s [info] Writing video subtitles to: video.en.srt [download] Destination: video.en.srt [download] 1.00KiB at Unknown B/s (00:00:00) [download] 3.00KiB at 2.03MiB/s (00:00:00) [download] 7.00KiB at 2.52MiB/s (00:00:00) [download] 15.00KiB at 4.50MiB/s (00:00:00) [download] 31.00KiB at 2.15MiB/s (00:00:00) [download] 35.58KiB at 2.26MiB/s (00:00:00) [download] 100% of 35.58KiB in 00:00:00 at 286.16KiB/s Exit code: 0

{ "command": "cd /tmp/yt_summary && yt-dlp --print title --print duration_string --print channel --print upload_date \"https://www.youtube.com/watch?v=oOQFV86uNXY\" 2>&1 | tail -20", "timeout": 60000 }

Output from command in shell 2ffd32: WARNING: Your yt-dlp version (2025.12.08) is older than 90 days! It is strongly recommended to always use the latest version. You installed yt-dlp with pip or using the wheel from PyPi; Use that to update. To suppress this warning, add --no-update to your command/config. WARNING: [youtube] [jsc] Remote components challenge solver script (deno) and NPM package (deno) were skipped. These may be required to solve JS challenges. You can enable these downloads with --remote-components ejs:github (recommended) or --remote-components ejs:npm , respectively. For more information and alternatives, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS WARNING: [youtube] oOQFV86uNXY: n challenge solving failed: Some formats may be missing. Ensure you have a supported JavaScript runtime and challenge solver script distribution installed. Review any warnings presented before this message. For more details, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS Sam Altman’s Forgotten Essay About How to Be Productive | Cal Newport 17:00 Cal Newport 20251204 Exit code: 0

<file-view path="/tmp/yt_summary/video.en-orig.srt" start_line="1" end_line="1110" total_lines="2016"> 1|1 2|00:00:01,199 --> 00:00:08,800 3|Back in 2018, 4| 5|2 6|00:00:04,000 --> 00:00:11,360 7|Sam Alman before he was famous Sam Alman 8| 9|3 10|00:00:08,800 --> 00:00:13,920 11|wrote a essay on the topic of 12| 13|4 14|00:00:11,360 --> 00:00:17,600 15|productivity where he laid out his 16| 17|5 18|00:00:13,920 --> 00:00:20,240 19|theory about how to produce work that 20| 21|6 22|00:00:17,600 --> 00:00:22,880 23|matters and how not to get caught up in 24| 25|7 26|00:00:20,240 --> 00:00:25,600 27|distractions. Well, earlier this year, I 28| 29|8 30|00:00:22,880 --> 00:00:28,080 31|tackled that essay in an episode of my 32| 33|9 34|00:00:25,600 --> 00:00:29,679 35|podcast. I looked at what he said and 36| 37|10 38|00:00:28,080 --> 00:00:31,519 39|pulled out the points that I think are 40| 41|11 42|00:00:29,679 --> 00:00:32,800 43|actually really quite telling and 44| 45|12 46|00:00:31,519 --> 00:00:34,800 47|actually really quite effective 48| 49|13 50|00:00:32,800 --> 00:00:36,719 51|regardless how you think about Altman 52| 53|14 54|00:00:34,800 --> 00:00:39,040 55|and his companies today. So, in the clip 56| 57|15 58|00:00:36,719 --> 00:00:41,200 59|I'm about to show you, we get into those 60| 61|16 62|00:00:39,040 --> 00:00:43,360 63|details. I introduce the article and I 64| 65|17 66|00:00:41,200 --> 00:00:44,800 67|pull out some ideas that I think might 68| 69|18 70|00:00:43,360 --> 00:00:47,280 71|really make a difference when you're 72| 73|19 74|00:00:44,800 --> 00:00:49,120 75|thinking about how to make your own work 76| 77|20 78|00:00:47,280 --> 00:00:50,480 79|more impactful in an age where 80| 81|21 82|00:00:49,120 --> 00:00:51,360 83|distractions try to pull you down. All 84| 85|22 86|00:00:50,480 --> 00:00:53,360 87|right, check this out. You're going to 88| 89|23 90|00:00:51,360 --> 00:00:56,000 91|like this clip. So, as someone who 92| 93|24 94|00:00:53,360 --> 00:00:58,160 95|writes and talks a lot about producing 96| 97|25 98|00:00:56,000 --> 00:01:00,719 99|meaningful stuff in a distracted world, 100| 101|26 102|00:00:58,160 --> 00:01:02,879 103|I always get excited when prominent 104| 105|27 106|00:01:00,719 --> 00:01:05,439 107|individuals give us insight into their 108| 109|28 110|00:01:02,879 --> 00:01:07,680 111|own processes for achieving this goal. 112| 113|29 114|00:01:05,439 --> 00:01:09,840 115|So, you can imagine how happy I was when 116| 117|30 118|00:01:07,680 --> 00:01:13,040 119|I saw Tim Ferrris recently link to a 120| 121|31 122|00:01:09,840 --> 00:01:14,640 123|blog post that was titled Simply 124| 125|32 126|00:01:13,040 --> 00:01:18,240 127|Productivity 128| 129|33 130|00:01:14,640 --> 00:01:21,840 131|that was published in 2018 by OpenAI's 132| 133|34 134|00:01:18,240 --> 00:01:24,560 135|Sam Alman. Here is the o uh opening two 136| 137|35 138|00:01:21,840 --> 00:01:26,159 139|sentences of this essay. I think I am at 140| 141|36 142|00:01:24,560 --> 00:01:28,159 143|least somewhat more productive than 144| 145|37 146|00:01:26,159 --> 00:01:30,240 147|average and people sometimes ask me for 148| 149|38 150|00:01:28,159 --> 00:01:34,240 151|productivity tips. So, I decided to just 152| 153|39 154|00:01:30,240 --> 00:01:35,840 155|write them all down in one place. So, 156| 157|40 158|00:01:34,240 --> 00:01:39,040 159|I'm excited about getting to this essay 160| 161|41 162|00:01:35,840 --> 00:01:40,720 163|because when Sam wrote it 2018, think 164| 165|42 166|00:01:39,040 --> 00:01:43,360 167|about it, OpenAI was at a crucial 168| 169|43 170|00:01:40,720 --> 00:01:45,600 171|turning point. They had just released 172| 173|44 174|00:01:43,360 --> 00:01:48,320 175|GPT1, but they were operating as a 176| 177|45 178|00:01:45,600 --> 00:01:49,840 179|nonprofit. Elon Musk had just left the 180| 181|46 182|00:01:48,320 --> 00:01:51,119 183|board of directors after failing to 184| 185|47 186|00:01:49,840 --> 00:01:53,119 187|convince the board that they should 188| 189|48 190|00:01:51,119 --> 00:01:55,280 191|merge OpenAI with his Tesla company to 192| 193|49 194|00:01:53,119 --> 00:01:58,240 195|help out its financial situation. 196| 197|50 198|00:01:55,280 --> 00:02:00,320 199|Instead, Sam led a move from a nonprofit 200| 201|51 202|00:01:58,240 --> 00:02:02,079 203|the next year to a cap profit status 204| 205|52 206|00:02:00,320 --> 00:02:03,759 207|that opened up venture capital funding. 208| 209|53 210|00:02:02,079 --> 00:02:05,920 211|They could hire a bunch more talent, and 212| 213|54 214|00:02:03,759 --> 00:02:08,560 215|that's really where the OpenAI story we 216| 217|55 218|00:02:05,920 --> 00:02:10,239 219|know today really took off. So, he was 220| 221|56 222|00:02:08,560 --> 00:02:13,040 223|pretty productive during this period. 224| 225|57 226|00:02:10,239 --> 00:02:14,959 227|So, it's useful to look back and say, 228| 229|58 230|00:02:13,040 --> 00:02:18,560 231|how was he thinking about getting 232| 233|59 234|00:02:14,959 --> 00:02:22,160 235|important work done on the eve of OpenAI 236| 237|60 238|00:02:18,560 --> 00:02:24,160 239|making all of these important leaps? So, 240| 241|61 242|00:02:22,160 --> 00:02:25,599 243|what I'm going to do is pull out I think 244| 245|62 246|00:02:24,160 --> 00:02:29,040 247|I have five, let me look at my notes 248| 249|63 250|00:02:25,599 --> 00:02:30,879 251|here. I have five ideas from his essay 252| 253|64 254|00:02:29,040 --> 00:02:32,720 255|and for each we'll get into it. I agree 256| 257|65 258|00:02:30,879 --> 00:02:34,000 259|with a lot. I disagree with others. I 260| 261|66 262|00:02:32,720 --> 00:02:35,920 263|think there's some big important ideas 264| 265|67 266|00:02:34,000 --> 00:02:37,519 267|he highlights in some. So, we will get 268| 269|68 270|00:02:35,920 --> 00:02:39,360 271|into Sam Altman's productivity essay. 272| 273|69 274|00:02:37,519 --> 00:02:41,120 275|Let me just load it on the screen now 276| 277|70 278|00:02:39,360 --> 00:02:42,800 279|for those who are watching instead of 280| 281|71 282|00:02:41,120 --> 00:02:44,560 283|listening. Uh this is what the essay 284| 285|72 286|00:02:42,800 --> 00:02:47,280 287|looks like. I missed that classic blog 288| 289|73 290|00:02:44,560 --> 00:02:48,959 291|format, Jesse, back in the the end of 292| 293|74 294|00:02:47,280 --> 00:02:50,640 295|web two where you kept things simple and 296| 297|75 298|00:02:48,959 --> 00:02:53,360 299|just wrote long essays. But here it is. 300| 301|76 302|00:02:50,640 --> 00:02:55,680 303|Published in April of 2018, so seven 304| 305|77 306|00:02:53,360 --> 00:02:57,200 307|years ago basically to the day. Um 308| 309|78 310|00:02:55,680 --> 00:02:58,400 311|that's what it looks like. So I'm going 312| 313|79 314|00:02:57,200 --> 00:02:59,840 315|to jump through here and I'm going to 316| 317|80 318|00:02:58,400 --> 00:03:01,599 319|pull out some quotes. All right, Jesse, 320| 321|81 322|00:02:59,840 --> 00:03:03,840 323|we can bring it back to full screen. All 324| 325|82 326|00:03:01,599 --> 00:03:07,280 327|right, here's idea number one. I'm 328| 329|83 330|00:03:03,840 --> 00:03:09,120 331|reading now from Sam's essay. 332| 333|84 334|00:03:07,280 --> 00:03:10,800 335|Compound growth gets discussed as a 336| 337|85 338|00:03:09,120 --> 00:03:13,360 339|financial concept, but it works in 340| 341|86 342|00:03:10,800 --> 00:03:15,120 343|careers as well, and it is magic. A 344| 345|87 346|00:03:13,360 --> 00:03:17,599 347|small productivity gain compounded over 348| 349|88 350|00:03:15,120 --> 00:03:18,959 351|50 years is worth a lot. So, it's worth 352| 353|89 354|00:03:17,599 --> 00:03:21,360 355|figuring out how to optimize 356| 357|90 358|00:03:18,959 --> 00:03:23,760 359|productivity. If you get 10% more done 360| 361|91 362|00:03:21,360 --> 00:03:26,800 363|and 1% better every day compared to 364| 365|92 366|00:03:23,760 --> 00:03:29,760 367|someone else, the compound difference is 368| 369|93 370|00:03:26,800 --> 00:03:31,599 371|massive. All right. So, I have mixed 372| 373|94 374|00:03:29,760 --> 00:03:33,840 375|feelings about this first idea of 376| 377|95 378|00:03:31,599 --> 00:03:35,360 379|applying the compound growth idea to 380| 381|96 382|00:03:33,840 --> 00:03:36,720 383|productivity. I think there's some piece 384| 385|97 386|00:03:35,360 --> 00:03:39,599 387|of this that's right and some piece of 388| 389|98 390|00:03:36,720 --> 00:03:43,120 391|this that's not right. The getting 1% 392| 393|99 394|00:03:39,599 --> 00:03:45,360 395|better. Sure. If you could get 1% better 396| 397|100 398|00:03:43,120 --> 00:03:47,519 399|at something every day, you are 400| 401|101 402|00:03:45,360 --> 00:03:49,680 403|compounding. So, your current skill 404| 405|102 406|00:03:47,519 --> 00:03:52,000 407|level grows that your 1% is being 408| 409|103 410|00:03:49,680 --> 00:03:53,920 411|applied to. And if you you put that out 412| 413|104 414|00:03:52,000 --> 00:03:55,760 415|over a certain number of years, you 416| 417|105 418|00:03:53,920 --> 00:03:57,439 419|would be the world's very best expert in 420| 421|106 422|00:03:55,760 --> 00:03:59,599 423|like five years or however the math 424| 425|107 426|00:03:57,439 --> 00:04:01,360 427|works out. Um, that's not really how 428| 429|108 430|00:03:59,599 --> 00:04:03,280 431|getting better works, though. It it 432| 433|109 434|00:04:01,360 --> 00:04:05,120 435|typically has long periods of practice. 436| 437|110 438|00:04:03,280 --> 00:04:06,720 439|It leads to new levels of skill. And 440| 441|111 442|00:04:05,120 --> 00:04:10,720 443|each level of skill is harder to get to 444| 445|112 446|00:04:06,720 --> 00:04:12,959 447|than the last. So, it's almost more of a 448| 449|113 450|00:04:10,720 --> 00:04:14,319 451|linear or like a slow linear function 452| 453|114 454|00:04:12,959 --> 00:04:16,160 455|that an exponential function like 456| 457|115 458|00:04:14,319 --> 00:04:17,600 459|compound interest would give you. You're 460| 461|116 462|00:04:16,160 --> 00:04:19,359 463|kind of getting better faster and then 464| 465|117 466|00:04:17,600 --> 00:04:21,519 467|it really slows down. It just gets 468| 469|118 470|00:04:19,359 --> 00:04:23,360 471|harder. to get to each new level. 472| 473|119 474|00:04:21,519 --> 00:04:25,759 475|Whereas compound interest, you get a 476| 477|120 478|00:04:23,360 --> 00:04:28,880 479|curve that picks up speed as it's going. 480| 481|121 482|00:04:25,759 --> 00:04:31,199 483|I also am concerned about him making the 484| 485|122 486|00:04:28,880 --> 00:04:33,919 487|slight shift. He's combining getting 1% 488| 489|123 490|00:04:31,199 --> 00:04:36,960 491|better as an example of compound growth 492| 493|124 494|00:04:33,919 --> 00:04:38,880 495|to doing 10% more each day. This doesn't 496| 497|125 498|00:04:36,960 --> 00:04:40,479 499|really jive with my study of long-term 500| 501|126 502|00:04:38,880 --> 00:04:42,080 503|productivity. If you looked at my book, 504| 505|127 506|00:04:40,479 --> 00:04:44,320 507|Slow Productivity, which came out last 508| 509|128 510|00:04:42,080 --> 00:04:47,440 511|year, one of the things I do is study 512| 513|129 514|00:04:44,320 --> 00:04:49,120 515|some of the most historically productive 516| 517|130 518|00:04:47,440 --> 00:04:50,639 519|people, meaning like what they produce, 520| 521|131 522|00:04:49,120 --> 00:04:52,080 523|historical figures that produce things 524| 525|132 526|00:04:50,639 --> 00:04:53,840 527|that we look back at now and say that 528| 529|133 530|00:04:52,080 --> 00:04:56,240 531|was super important. What a productive 532| 533|134 534|00:04:53,840 --> 00:04:58,560 535|intellectual life they had. So, Galileo 536| 537|135 538|00:04:56,240 --> 00:05:01,440 539|or Newton or Mary Cury or Jane Austin, 540| 541|136 542|00:04:58,560 --> 00:05:04,880 543|etc. And what you find in these stories 544| 545|137 546|00:05:01,440 --> 00:05:07,280 547|is their key was not getting more done 548| 549|138 550|00:05:04,880 --> 00:05:10,400 551|each day. In fact, what I highlighted 552| 553|139 554|00:05:07,280 --> 00:05:13,520 555|was there was a certain notable slowness 556| 557|140 558|00:05:10,400 --> 00:05:15,600 559|or even lack of urgency behind their 560| 561|141 562|00:05:13,520 --> 00:05:17,840 563|biggest achievements. They thought about 564| 565|142 566|00:05:15,600 --> 00:05:19,520 567|it. They had long digressions into other 568| 569|143 570|00:05:17,840 --> 00:05:21,440 571|interests. They would come back to them. 572| 573|144 574|00:05:19,520 --> 00:05:23,360 575|They would let it marinate. And 576| 577|145 578|00:05:21,440 --> 00:05:25,919 579|ultimately, it didn't really matter. The 580| 581|146 582|00:05:23,360 --> 00:05:27,680 583|the the busyiness or phoneticism of any 584| 585|147 586|00:05:25,919 --> 00:05:29,360 587|given day wasn't important. It was more 588| 589|148 590|00:05:27,680 --> 00:05:30,880 591|about the consistent application of 592| 593|149 594|00:05:29,360 --> 00:05:32,000 595|thought over a long period of time that 596| 597|150 598|00:05:30,880 --> 00:05:33,520 599|eventually led to really big 600| 601|151 602|00:05:32,000 --> 00:05:35,039 603|breakthroughs. 604| 605|152 606|00:05:33,520 --> 00:05:37,440 607|So when it comes to producing really 608| 609|153 610|00:05:35,039 --> 00:05:39,759 611|meaningful stuff, I don't know that this 612| 613|154 614|00:05:37,440 --> 00:05:41,440 615|idea of I get 10% more done each day 616| 617|155 618|00:05:39,759 --> 00:05:42,880 619|really matters. I think where that will 620| 621|156 622|00:05:41,440 --> 00:05:44,479 623|lead to more often than not is just 624| 625|157 626|00:05:42,880 --> 00:05:46,960 627|busy. That's the easiest thing to get 628| 629|158 630|00:05:44,479 --> 00:05:48,800 631|10% more done of and busyness doesn't 632| 633|159 634|00:05:46,960 --> 00:05:50,080 635|necessarily transmute into results. All 636| 637|160 638|00:05:48,800 --> 00:05:52,320 639|right, so that's an idea where I'm not 640| 641|161 642|00:05:50,080 --> 00:05:55,120 643|completely on board with the way Altman 644| 645|162 646|00:05:52,320 --> 00:05:56,560 647|is summarizing things. Idea two, 648| 649|163 650|00:05:55,120 --> 00:05:59,440 651|however, I'm very much on board with. 652| 653|164 654|00:05:56,560 --> 00:06:02,000 655|Let me read now from Altman's essay. 656| 657|165 658|00:05:59,440 --> 00:06:04,639 659|It doesn't matter how fast you move if 660| 661|166 662|00:06:02,000 --> 00:06:06,400 663|it's in a worthless direction. Picking 664| 665|167 666|00:06:04,639 --> 00:06:08,319 667|the right thing to work on is the most 668| 669|168 670|00:06:06,400 --> 00:06:10,720 671|important element of productivity and 672| 673|169 674|00:06:08,319 --> 00:06:13,039 675|usually almost ignored. So, think about 676| 677|170 678|00:06:10,720 --> 00:06:14,479 679|it more. I make sure to leave enough 680| 681|171 682|00:06:13,039 --> 00:06:16,479 683|time in my schedule to think about what 684| 685|172 686|00:06:14,479 --> 00:06:17,840 687|to work on. The best ways for me to do 688| 689|173 690|00:06:16,479 --> 00:06:20,319 691|this are reading books, hanging out with 692| 693|174 694|00:06:17,840 --> 00:06:21,840 695|interesting people, and spending time in 696| 697|175 698|00:06:20,319 --> 00:06:23,759 699|nature. 700| 701|176 702|00:06:21,840 --> 00:06:25,520 703|Interestingly, this is somewhat 704| 705|177 706|00:06:23,759 --> 00:06:27,039 707|contradictory to idea number one, which 708| 709|178 710|00:06:25,520 --> 00:06:28,240 711|is like, hey, get 10% more done each 712| 713|179 714|00:06:27,039 --> 00:06:29,600 715|day. It'll add up. and you say, "No, 716| 717|180 718|00:06:28,240 --> 00:06:31,120 719|take your time. Don't get started. Think 720| 721|181 722|00:06:29,600 --> 00:06:33,120 723|more. Hang out in nature. Hang out with 724| 725|182 726|00:06:31,120 --> 00:06:34,560 727|interesting people. Read. Wait to get 728| 729|183 730|00:06:33,120 --> 00:06:36,720 731|started. Really make sure that you have 732| 733|184 734|00:06:34,560 --> 00:06:39,199 735|the right thing to work on." I'm a big 736| 737|185 738|00:06:36,720 --> 00:06:41,120 739|believer in that idea. I remember I 740| 741|186 742|00:06:39,199 --> 00:06:43,680 743|wrote an essay about this way back early 744| 745|187 746|00:06:41,120 --> 00:06:47,199 747|in my writing career. I wrote an essay 748| 749|188 750|00:06:43,680 --> 00:06:49,199 751|for Ramit Seth's blog and it was called 752| 753|189 754|00:06:47,199 --> 00:06:52,160 755|don't get started. 756| 757|190 758|00:06:49,199 --> 00:06:55,759 759|My argument was it is basically Sam's 760| 761|191 762|00:06:52,160 --> 00:06:58,400 763|argument. It is really hard to figure 764| 765|192 766|00:06:55,759 --> 00:07:00,240 767|out the right thing to work on, the 768| 769|193 770|00:06:58,400 --> 00:07:01,919 771|thing that's going to matter and that 772| 773|194 774|00:07:00,240 --> 00:07:04,080 775|uses the the rare and valuable skills 776| 777|195 778|00:07:01,919 --> 00:07:05,520 779|that you currently possess. 780| 781|196 782|00:07:04,080 --> 00:07:06,880 783|And you it's probably going to take a 784| 785|197 786|00:07:05,520 --> 00:07:08,560 787|long time once you choose the right 788| 789|198 790|00:07:06,880 --> 00:07:10,000 791|thing to get really good results. So you 792| 793|199 794|00:07:08,560 --> 00:07:11,199 795|want to be really wary of just diving 796| 797|200 798|00:07:10,000 --> 00:07:12,479 799|into things because when you dive into 800| 801|201 802|00:07:11,199 --> 00:07:14,880 803|things, you're basically flooding your 804| 805|202 806|00:07:12,479 --> 00:07:16,720 807|circuits with activity and you are 808| 809|203 810|00:07:14,880 --> 00:07:19,120 811|taking them out of the game for working 812| 813|204 814|00:07:16,720 --> 00:07:20,800 815|on other more important things. So 816| 817|205 818|00:07:19,120 --> 00:07:22,319 819|resist working on things. I often say 820| 821|206 822|00:07:20,800 --> 00:07:23,919 823|with big projects, resist working on 824| 825|207 826|00:07:22,319 --> 00:07:25,840 827|them. Think about them, read about them, 828| 829|208 830|00:07:23,919 --> 00:07:27,440 831|get excited about them, but resist 832| 833|209 834|00:07:25,840 --> 00:07:30,800 835|working on them until you can't help it 836| 837|210 838|00:07:27,440 --> 00:07:33,840 839|anymore. Sort of like me with bookw 840| 841|211 842|00:07:30,800 --> 00:07:36,720 843|writing, me with this podcast. Man, I 844| 845|212 846|00:07:33,840 --> 00:07:38,960 847|resisted podcasting for a long time. I 848| 849|213 850|00:07:36,720 --> 00:07:40,319 851|learned a lot about it's not quite 852| 853|214 854|00:07:38,960 --> 00:07:41,360 855|right. I I don't want to just do it for 856| 857|215 858|00:07:40,319 --> 00:07:43,039 859|the sake of doing it. I don't like 860| 861|216 862|00:07:41,360 --> 00:07:45,520 863|activity for the sake of activity. Took 864| 865|217 866|00:07:43,039 --> 00:07:47,120 867|me years before I said, "Okay, I can't 868| 869|218 870|00:07:45,520 --> 00:07:49,039 871|avoid this any longer." That's really 872| 873|219 874|00:07:47,120 --> 00:07:52,560 875|what you should be looking for. Fewer 876| 877|220 878|00:07:49,039 --> 00:07:54,319 879|things done better. That has been a 880| 881|221 882|00:07:52,560 --> 00:07:56,400 883|theme through my work so long that the 884| 885|222 886|00:07:54,319 --> 00:07:58,080 887|original one of the original mottos of 888| 889|223 890|00:07:56,400 --> 00:07:59,840 891|my study hacks blog back when it was 892| 893|224 894|00:07:58,080 --> 00:08:02,800 895|still focused on students was do less, 896| 897|225 898|00:07:59,840 --> 00:08:04,960 899|do better, know why. Do less, do better. 900| 901|226 902|00:08:02,800 --> 00:08:06,800 903|It's a key idea. So I think Sam is 904| 905|227 906|00:08:04,960 --> 00:08:08,400 907|absolutely on to it there. Uh that's 908| 909|228 910|00:08:06,800 --> 00:08:10,160 911|probably reflected in OpenAI. They kind 912| 913|229 914|00:08:08,400 --> 00:08:11,520 915|of chose their points. They chose their 916| 917|230 918|00:08:10,160 --> 00:08:13,360 919|battles where they thought there could 920| 921|231 922|00:08:11,520 --> 00:08:15,280 923|be big work. For example, working on 924| 925|232 926|00:08:13,360 --> 00:08:17,199 927|very large scale language models and 928| 929|233 930|00:08:15,280 --> 00:08:19,680 931|then they went down that road year after 932| 933|234 934|00:08:17,199 --> 00:08:21,599 935|year. So, they carefully chose what they 936| 937|235 938|00:08:19,680 --> 00:08:22,960 939|were working on and then really gave 940| 941|236 942|00:08:21,599 --> 00:08:24,160 943|that a lot of attention over time. 944| 945|237 946|00:08:22,960 --> 00:08:26,960 947|That's where the big breakthroughs came 948| 949|238 950|00:08:24,160 --> 00:08:28,160 951|from. All right, idea number three. Now, 952| 953|239 954|00:08:26,960 --> 00:08:30,319 955|we're going to get into the weeds of 956| 957|240 958|00:08:28,160 --> 00:08:32,159 959|actual time management. 960| 961|241 962|00:08:30,319 --> 00:08:34,560 963|Here's Sam. 964| 965|242 966|00:08:32,159 --> 00:08:36,080 967|I highly recommend using list. I make 968| 969|243 970|00:08:34,560 --> 00:08:38,320 971|lists of what I want to accomplish each 972| 973|244 974|00:08:36,080 --> 00:08:40,000 975|year, each month, and each day. Lists 976| 977|245 978|00:08:38,320 --> 00:08:41,440 979|are very focusing, and they help me with 980| 981|246 982|00:08:40,000 --> 00:08:43,440 983|multitasking because I don't have to 984| 985|247 986|00:08:41,440 --> 00:08:45,200 987|keep as much in my head. If I'm not in 988| 989|248 990|00:08:43,440 --> 00:08:46,640 991|the mood for some particular task, I can 992| 993|249 994|00:08:45,200 --> 00:08:47,920 995|always find something else I'm excited 996| 997|250 998|00:08:46,640 --> 00:08:49,600 999|to do. 1000| 1001|251 1002|00:08:47,920 --> 00:08:51,680 1003|later. He says,"I don't bother with 1004| 1005|252 1006|00:08:49,600 --> 00:08:53,040 1007|categorization or trying to size task or 1008| 1009|253 1010|00:08:51,680 --> 00:08:55,200 1011|anything like that. The most I do is put 1012| 1013|254 1014|00:08:53,040 --> 00:08:56,399 1015|a star next to really important items. I 1016| 1017|255 1018|00:08:55,200 --> 00:08:58,320 1019|try to prioritize in a way that 1020| 1021|256 1022|00:08:56,399 --> 00:09:00,000 1023|generates momentum. The more I get done, 1024| 1025|257 1026|00:08:58,320 --> 00:09:02,240 1027|the better I feel and then the more I 1028| 1029|258 1030|00:09:00,000 --> 00:09:04,080 1031|get done. I like to start and end each 1032| 1033|259 1034|00:09:02,240 --> 00:09:06,720 1035|day with something I can really make 1036| 1037|260 1038|00:09:04,080 --> 00:09:10,480 1039|progress on. A couple interesting points 1040| 1041|261 1042|00:09:06,720 --> 00:09:13,040 1043|about his approach here. One, we do see 1044| 1045|262 1046|00:09:10,480 --> 00:09:15,920 1047|him preaching a principle that I talk a 1048| 1049|263 1050|00:09:13,040 --> 00:09:17,600 1051|lot on this show, which comes from David 1052| 1053|264 1054|00:09:15,920 --> 00:09:19,200 1055|Allen, who himself took it from Dean 1056| 1057|265 1058|00:09:17,600 --> 00:09:21,600 1059|Achinson, which is the notion of full 1060| 1061|266 1062|00:09:19,200 --> 00:09:22,880 1063|capture. Having things written down and 1064| 1065|267 1066|00:09:21,600 --> 00:09:24,399 1067|not being kept track of just in your 1068| 1069|268 1070|00:09:22,880 --> 00:09:26,080 1071|head is critical for avoiding 1072| 1073|269 1074|00:09:24,399 --> 00:09:28,560 1075|unnecessary stress and forgotten 1076| 1077|270 1078|00:09:26,080 --> 00:09:30,560 1079|deadlines and scrambles. Do not use your 1080| 1081|271 1082|00:09:28,560 --> 00:09:32,720 1083|brain as a task storage device or a 1084| 1085|272 1086|00:09:30,560 --> 00:09:34,080 1087|calendar. Use test storage devices or 1088| 1089|273 1090|00:09:32,720 --> 00:09:36,880 1091|calendars for that role. And he makes 1092| 1093|274 1094|00:09:34,080 --> 00:09:38,560 1095|that clear here. He says, "Look, um, 1096| 1097|275 1098|00:09:36,880 --> 00:09:39,760 1099|they help me with multitasking as I 1100| 1101|276 1102|00:09:38,560 --> 00:09:41,120 1103|don't have to keep as much in my head." 1104| 1105|277 1106|00:09:39,760 --> 00:09:42,880 1107|And by multitasking, he means just 1108| 1109|278 1110|00:09:41,120 --> 00:09:46,640 </file-view>

<file-view path="/tmp/yt_summary/video.en-orig.srt" start_line="1111" end_line="2016" total_lines="2016"> 1111|having multiple projects going on at the 1112| 1113|279 1114|00:09:42,880 --> 00:09:48,000 1115|same time. Um, so that's useful. I also 1116| 1117|280 1118|00:09:46,640 --> 00:09:49,440 1119|notice, however, the simplicity of his 1120| 1121|281 1122|00:09:48,000 --> 00:09:50,880 1123|systems. He just just like writes things 1124| 1125|282 1126|00:09:49,440 --> 00:09:52,560 1127|down on a list on paper. He doesn't 1128| 1129|283 1130|00:09:50,880 --> 00:09:54,560 1131|break it up into categories. He doesn't 1132| 1133|284 1134|00:09:52,560 --> 00:09:55,680 1135|do any sort of prioritization. He just 1136| 1137|285 1138|00:09:54,560 --> 00:09:58,080 1139|sort of looks at the list and says, 1140| 1141|286 1142|00:09:55,680 --> 00:09:59,600 1143|"What do I want to work on next?" Maybe 1144| 1145|287 1146|00:09:58,080 --> 00:10:01,920 1147|he'll put a star next to something to 1148| 1149|288 1150|00:09:59,600 --> 00:10:05,200 1151|really remind him that it's important to 1152| 1153|289 1154|00:10:01,920 --> 00:10:07,440 1155|get it done. that type of basic system, 1156| 1157|290 1158|00:10:05,200 --> 00:10:09,519 1159|a sort of uh what's known as an MIT 1160| 1161|291 1162|00:10:07,440 --> 00:10:10,640 1163|system, most important task system. It's 1164| 1165|292 1166|00:10:09,519 --> 00:10:13,600 1167|been around. It's an idea that's been 1168| 1169|293 1170|00:10:10,640 --> 00:10:16,320 1171|around for a while. Um, we hear it in 1172| 1173|294 1174|00:10:13,600 --> 00:10:18,160 1175|the early 2000s. We hear Julie Morgan 1176| 1177|295 1178|00:10:16,320 --> 00:10:19,839 1179|Stern talking about this. We hear Brian 1180| 1181|296 1182|00:10:18,160 --> 00:10:22,079 1183|Tracy talking about this. We hear Leo 1184| 1185|297 1186|00:10:19,839 --> 00:10:24,000 1187|Babuds and Habits talking about this. 1188| 1189|298 1190|00:10:22,079 --> 00:10:25,440 1191|Even more recently, when Oliver Burkeman 1192| 1193|299 1194|00:10:24,000 --> 00:10:27,519 1195|came on my show last fall, this was 1196| 1197|300 1198|00:10:25,440 --> 00:10:28,880 1199|basically what he was pitching. Get the 1200| 1201|301 1202|00:10:27,519 --> 00:10:30,240 1203|important thing done first and then kind 1204| 1205|302 1206|00:10:28,880 --> 00:10:32,240 1207|of do your best with the rest of the 1208| 1209|303 1210|00:10:30,240 --> 00:10:36,000 1211|day. 1212| 1213|304 1214|00:10:32,240 --> 00:10:38,880 1215|It works and it doesn't. So I mean it 1216| 1217|305 1218|00:10:36,000 --> 00:10:41,040 1219|works in the sense of if your goal is to 1220| 1221|306 1222|00:10:38,880 --> 00:10:43,360 1223|make progress on what's important. This 1224| 1225|307 1226|00:10:41,040 --> 00:10:44,720 1227|is emphasizing that really just means 1228| 1229|308 1230|00:10:43,360 --> 00:10:46,320 1231|doing the important things and making 1232| 1233|309 1234|00:10:44,720 --> 00:10:48,800 1235|progress. 1236| 1237|310 1238|00:10:46,320 --> 00:10:50,560 1239|So I I think the fact that Sam had this 1240| 1241|311 1242|00:10:48,800 --> 00:10:53,760 1243|sort of simple system. I just make sure 1244| 1245|312 1246|00:10:50,560 --> 00:10:55,760 1247|the important stuff gets done 1248| 1249|313 1250|00:10:53,760 --> 00:10:57,040 1251|shows how when it comes to long-term 1252| 1253|314 1254|00:10:55,760 --> 00:10:58,399 1255|productivity, this is really different 1256| 1257|315 1258|00:10:57,040 --> 00:11:00,160 1259|than busyiness. This is really different 1260| 1261|316 1262|00:10:58,399 --> 00:11:02,560 1263|than I'm quick on my emails and Slack. 1264| 1265|317 1266|00:11:00,160 --> 00:11:05,040 1267|I'm jumping on a bunch of calls. Uh for 1268| 1269|318 1270|00:11:02,560 --> 00:11:06,160 1271|Sam, his productivity was dependent on 1272| 1273|319 1274|00:11:05,040 --> 00:11:08,640 1275|doing a small number of things 1276| 1277|320 1278|00:11:06,160 --> 00:11:10,640 1279|consistently. Well, the issue is for a 1280| 1281|321 1282|00:11:08,640 --> 00:11:14,000 1283|lot of us, there's a lot of other stuff 1284| 1285|322 1286|00:11:10,640 --> 00:11:15,360 1287|too that we have to do that is not just, 1288| 1289|323 1290|00:11:14,000 --> 00:11:17,200 1291|hey, here's the project I want to work 1292| 1293|324 1294|00:11:15,360 --> 00:11:18,800 1295|on. It is I have to get back to this 1296| 1297|325 1298|00:11:17,200 --> 00:11:20,959 1299|person. This dean wants to know this. My 1300| 1301|326 1302|00:11:18,800 --> 00:11:22,720 1303|students need me to sign this. The 1304| 1305|327 1306|00:11:20,959 --> 00:11:24,160 1307|parking office needs me to update my 1308| 1309|328 1310|00:11:22,720 --> 00:11:25,519 1311|license plate for the new license plate 1312| 1313|329 1314|00:11:24,160 --> 00:11:27,360 1315|readers they installed in the Levy 1316| 1317|330 1318|00:11:25,519 --> 00:11:30,079 1319|garage. Just making these up on the top 1320| 1321|331 1322|00:11:27,360 --> 00:11:32,560 1323|of my head here. and we can't say no to 1324| 1325|332 1326|00:11:30,079 --> 00:11:34,000 1327|those things. So that's the context 1328| 1329|333 1330|00:11:32,560 --> 00:11:36,320 1331|where you actually probably need a more 1332| 1333|334 1334|00:11:34,000 --> 00:11:39,200 1335|complicated task storage system because 1336| 1337|335 1338|00:11:36,320 --> 00:11:41,920 1339|you can't just if you have many 1340| 1341|336 1342|00:11:39,200 --> 00:11:43,519 1343|unignorable demands on your time. So you 1344| 1345|337 1346|00:11:41,920 --> 00:11:45,920 1347|have the big like Sam's focusing on in 1348| 1349|338 1350|00:11:43,519 --> 00:11:47,040 1351|the small. If you just have a big list 1352| 1353|339 1354|00:11:45,920 --> 00:11:48,160 1355|and you're just trying to choose from 1356| 1357|340 1358|00:11:47,040 --> 00:11:49,680 1359|there, hey, what's the big thing I want 1360| 1361|341 1362|00:11:48,160 --> 00:11:51,120 1363|to work on today? That small stuff is 1364| 1365|342 1366|00:11:49,680 --> 00:11:52,160 1367|going to eat away at you because you're 1368| 1369|343 1370|00:11:51,120 --> 00:11:53,600 1371|going to miss things. People are going 1372| 1373|344 1374|00:11:52,160 --> 00:11:55,279 1375|to yell at you. Small things will get 1376| 1377|345 1378|00:11:53,600 --> 00:11:56,480 1379|missed. People will like, where's this? 1380| 1381|346 1382|00:11:55,279 --> 00:11:57,680 1383|Where's that? Your car is going to get a 1384| 1385|347 1386|00:11:56,480 --> 00:11:58,880 1387|ticket because you didn't update your 1388| 1389|348 1390|00:11:57,680 --> 00:12:00,240 1391|license plate information. And that's 1392| 1393|349 1394|00:11:58,880 --> 00:12:03,200 1395|going to become a source of stress and a 1396| 1397|350 1398|00:12:00,240 --> 00:12:05,200 1399|problem. So I like the point that Sam is 1400| 1401|351 1402|00:12:03,200 --> 00:12:06,720 1403|making here. It's like ultimately just 1404| 1405|352 1406|00:12:05,200 --> 00:12:08,240 1407|doing something important every day is 1408| 1409|353 1410|00:12:06,720 --> 00:12:09,920 1411|what matters for the stuff that people 1412| 1413|354 1414|00:12:08,240 --> 00:12:12,800 1415|will remember you for. The busyiness 1416| 1417|355 1418|00:12:09,920 --> 00:12:14,160 1419|doesn't produce stuff that matters. 1420| 1421|356 1422|00:12:12,800 --> 00:12:16,800 1423|But if you have a lot of that other 1424| 1425|357 1426|00:12:14,160 --> 00:12:18,160 1427|stuff, smarter task storage might be 1428| 1429|358 1430|00:12:16,800 --> 00:12:20,560 1431|important. Right? This is why I like to 1432| 1433|359 1434|00:12:18,160 --> 00:12:21,920 1435|store stuff in cognitive context. So I 1436| 1437|360 1438|00:12:20,560 --> 00:12:23,680 1439|could say I'm going to spend time on 1440| 1441|361 1442|00:12:21,920 --> 00:12:25,360 1443|like my professor role and just see 1444| 1445|362 1446|00:12:23,680 --> 00:12:27,040 1447|tasks for that divided into statuses. 1448| 1449|363 1450|00:12:25,360 --> 00:12:29,360 1451|So, it's very easy to sort of see what's 1452| 1453|364 1454|00:12:27,040 --> 00:12:30,720 1455|what and what needs to get done. So, 1456| 1457|365 1458|00:12:29,360 --> 00:12:32,079 1459|smarter task storage, I think, is 1460| 1461|366 1462|00:12:30,720 --> 00:12:33,600 1463|necessary if you have a lot to do. But 1464| 1465|367 1466|00:12:32,079 --> 00:12:35,279 1467|don't forget Sam's big lesson here, 1468| 1469|368 1470|00:12:33,600 --> 00:12:37,120 1471|which is, yeah, but the small stuff is 1472| 1473|369 1474|00:12:35,279 --> 00:12:39,600 1475|secondary. Do the best you can with 1476| 1477|370 1478|00:12:37,120 --> 00:12:41,360 1479|that. Organize it in a way that's going 1480| 1481|371 1482|00:12:39,600 --> 00:12:42,880 1483|to save you from stress, but it's really 1484| 1485|372 1486|00:12:41,360 --> 00:12:44,880 1487|working on the important things each day 1488| 1489|373 1490|00:12:42,880 --> 00:12:46,240 1491|that's going to matter. 1492| 1493|374 1494|00:12:44,880 --> 00:12:49,519 1495|All right, idea number four from Sam 1496| 1497|375 1498|00:12:46,240 --> 00:12:51,279 1499|Alman. Here's Sam. I try to be ruthless 1500| 1501|376 1502|00:12:49,519 --> 00:12:53,040 1503|about saying no to stuff and doing 1504| 1505|377 1506|00:12:51,279 --> 00:12:55,440 1507|non-critical things in the quickest way 1508| 1509|378 1510|00:12:53,040 --> 00:12:57,360 1511|possible. I probably take this too far. 1512| 1513|379 1514|00:12:55,440 --> 00:12:58,720 1515|For example, I am almost sure I am turs 1516| 1517|380 1518|00:12:57,360 --> 00:13:00,160 1519|to the point of rudess when replying to 1520| 1521|381 1522|00:12:58,720 --> 00:13:01,760 1523|emails. I generally try to avoid 1524| 1525|382 1526|00:13:00,160 --> 00:13:04,480 1527|meetings and conferences as I find the 1528| 1529|383 1530|00:13:01,760 --> 00:13:05,920 1531|time cost to be huge. Again, I think 1532| 1533|384 1534|00:13:04,480 --> 00:13:07,839 1535|there's a critical point here. Whether 1536| 1537|385 1538|00:13:05,920 --> 00:13:11,040 1539|or not you have the power to say no to 1540| 1541|386 1542|00:13:07,839 --> 00:13:13,920 1543|everything, it emphasizes how almost 1544| 1545|387 1546|00:13:11,040 --> 00:13:15,600 1547|everything doesn't matter. Like, this is 1548| 1549|388 1550|00:13:13,920 --> 00:13:18,240 1551|a a theme I think that goes through 1552| 1553|389 1554|00:13:15,600 --> 00:13:20,959 1555|Sam's essay here. the things that 1556| 1557|390 1558|00:13:18,240 --> 00:13:23,680 1559|mattered that made OpenAI from a 1560| 1561|391 1562|00:13:20,959 --> 00:13:26,000 1563|struggling nonprofit to a company with a 1564| 1565|392 1566|00:13:23,680 --> 00:13:27,680 1567|massive valuation and huge impact on the 1568| 1569|393 1570|00:13:26,000 --> 00:13:30,240 1571|the world technological and economic 1572| 1573|394 1574|00:13:27,680 --> 00:13:32,000 1575|scene. The things that mattered were 1576| 1577|395 1578|00:13:30,240 --> 00:13:34,480 1579|small and hard and he was pretty 1580| 1581|396 1582|00:13:32,000 --> 00:13:36,639 1583|ruthless about coming back to them. So 1584| 1585|397 1586|00:13:34,480 --> 00:13:38,000 1587|if you worry about saying no to stuff 1588| 1589|398 1590|00:13:36,639 --> 00:13:40,560 1591|thinking that this somehow makes you 1592| 1593|399 1594|00:13:38,000 --> 00:13:42,399 1595|less productive, keep in mind this uber 1596| 1597|400 1598|00:13:40,560 --> 00:13:45,120 1599|productive individual's productivity was 1600| 1601|401 1602|00:13:42,399 --> 00:13:47,680 1603|built on his default of I really don't 1604| 1605|402 1606|00:13:45,120 --> 00:13:50,320 1607|want to do stuff. most stuff is just 1608| 1609|403 1610|00:13:47,680 --> 00:13:52,480 1611|getting in the way of time. Taking my 1612| 1613|404 1614|00:13:50,320 --> 00:13:55,040 1615|time away from the stuff I know for sure 1616| 1617|405 1618|00:13:52,480 --> 00:13:56,639 1619|is going to be really valuable. 1620| 1621|406 1622|00:13:55,040 --> 00:14:00,240 1623|More executives should probably follow 1624| 1625|407 1626|00:13:56,639 --> 00:14:01,360 1627|that uh advice as well, right? I mean, 1628| 1629|408 1630|00:14:00,240 --> 00:14:02,720 1631|I've talked to more than a few 1632| 1633|409 1634|00:14:01,360 --> 00:14:03,839 1635|executives who would have been in Sam's 1636| 1637|410 1638|00:14:02,720 --> 00:14:05,279 1639|position at different companies to say, 1640| 1641|411 1642|00:14:03,839 --> 00:14:07,279 1643|"No, my job is right. I have to be in 1644| 1645|412 1646|00:14:05,279 --> 00:14:08,240 1647|meetings. How can I say no to them?" 1648| 1649|413 1650|00:14:07,279 --> 00:14:10,160 1651|And you're saying, "Well, because if you 1652| 1653|414 1654|00:14:08,240 --> 00:14:11,680 1655|want to be good at what you do, the 1656| 1657|415 1658|00:14:10,160 --> 00:14:14,160 1659|meetings aren't really what matters so 1660| 1661|416 1662|00:14:11,680 --> 00:14:15,519 1663|much as like you understanding, pushing, 1664| 1665|417 1666|00:14:14,160 --> 00:14:16,959 1667|and developing the ideas are going to 1668| 1669|418 1670|00:14:15,519 --> 00:14:19,519 1671|make the biggest difference." All right, 1672| 1673|419 1674|00:14:16,959 --> 00:14:21,519 1675|idea number five from Sam. I have 1676| 1677|420 1678|00:14:19,519 --> 00:14:23,199 1679|different times a day I try to use for 1680| 1681|421 1682|00:14:21,519 --> 00:14:24,480 1683|different kinds of work. The first few 1684| 1685|422 1686|00:14:23,199 --> 00:14:26,320 1687|hours of the morning are definitely my 1688| 1689|423 1690|00:14:24,480 --> 00:14:28,079 1691|most productive time of the day, so I 1692| 1693|424 1694|00:14:26,320 --> 00:14:30,240 1695|don't let anyone schedule anything. Then 1696| 1697|425 1698|00:14:28,079 --> 00:14:32,160 1699|I try to do meetings in the afternoon. 1700| 1701|426 1702|00:14:30,240 --> 00:14:34,320 1703|Another great idea, the morning is a 1704| 1705|427 1706|00:14:32,160 --> 00:14:35,920 1707|good time for deep work for most people. 1708| 1709|428 1710|00:14:34,320 --> 00:14:38,399 1711|So just having a simple rule, I don't do 1712| 1713|429 1714|00:14:35,920 --> 00:14:40,720 1715|meetings until this point makes a big 1716| 1717|430 1718|00:14:38,399 --> 00:14:43,120 1719|difference. I was chatting recently with 1720| 1721|431 1722|00:14:40,720 --> 00:14:45,680 1723|a president of a former president of a 1724| 1725|432 1726|00:14:43,120 --> 00:14:47,360 1727|large company and he was saying this was 1728| 1729|433 1730|00:14:45,680 --> 00:14:49,199 1731|a huge change for him is that they were 1732| 1733|434 1734|00:14:47,360 --> 00:14:51,920 1735|just filling his days with meetings, his 1736| 1737|435 1738|00:14:49,199 --> 00:14:54,000 1739|staff. And at some point they said, 1740| 1741|436 1742|00:14:51,920 --> 00:14:55,839 1743|"Okay, you know, we're going to protect 1744| 1745|437 1746|00:14:54,000 --> 00:14:58,320 1747|time in the morning for just working on 1748| 1749|438 1750|00:14:55,839 --> 00:14:59,680 1751|your own stuff." And he was worried this 1752| 1753|439 1754|00:14:58,320 --> 00:15:01,760 1755|would make him a worse executive. 1756| 1757|440 1758|00:14:59,680 --> 00:15:03,120 1759|Instead made him way better. There's 1760| 1761|441 1762|00:15:01,760 --> 00:15:05,519 1763|endless people that want your time. 1764| 1765|442 1766|00:15:03,120 --> 00:15:07,120 1767|There's endless meetings you could take. 1768| 1769|443 1770|00:15:05,519 --> 00:15:08,959 1771|You're already constraining the meetings 1772| 1773|444 1774|00:15:07,120 --> 00:15:10,160 1775|you can take because your day is only so 1776| 1777|445 1778|00:15:08,959 --> 00:15:12,480 1779|long. So why not just change those 1780| 1781|446 1782|00:15:10,160 --> 00:15:13,680 1783|constraints even more so you have more 1784| 1785|447 1786|00:15:12,480 --> 00:15:15,360 1787|time to work on the big thoughts that 1788| 1789|448 1790|00:15:13,680 --> 00:15:17,120 1791|are going to matter as well. If Sam 1792| 1793|449 1794|00:15:15,360 --> 00:15:20,000 1795|Alman can do it, you can probably do it 1796| 1797|450 1798|00:15:17,120 --> 00:15:22,639 1799|as well. So ultimately I think Sam has a 1800| 1801|451 1802|00:15:20,000 --> 00:15:25,360 1803|lot of non-surprising advice here. I 1804| 1805|452 1806|00:15:22,639 --> 00:15:27,360 1807|mean I think he would would have been 1808| 1809|453 1810|00:15:25,360 --> 00:15:28,959 1811|these ideas would have fit well in my 1812| 1813|454 1814|00:15:27,360 --> 00:15:30,399 1815|book Slow Productivity. These ideas 1816| 1817|455 1818|00:15:28,959 --> 00:15:32,079 1819|would have fit well in my book deep 1820| 1821|456 1822|00:15:30,399 --> 00:15:33,600 1823|work. And perhaps this is not surprising 1824| 1825|457 1826|00:15:32,079 --> 00:15:35,519 1827|because he ended up being very 1828| 1829|458 1830|00:15:33,600 --> 00:15:37,760 1831|successful at what he did. He worked on 1832| 1833|459 1834|00:15:35,519 --> 00:15:40,720 1835|deep stuff in a distracted world. I want 1836| 1837|460 1838|00:15:37,760 --> 00:15:42,720 1839|to end with a a quote from Sam's essay 1840| 1841|461 1842|00:15:40,720 --> 00:15:45,199 1843|that I think summarizes well the gist of 1844| 1845|462 1846|00:15:42,720 --> 00:15:47,040 1847|his whole philosophy here. 1848| 1849|463 1850|00:15:45,199 --> 00:15:49,040 1851|Don't fall into the trap of productivity 1852| 1853|464 1854|00:15:47,040 --> 00:15:51,600 1855|porn. Chasing productivity for its own 1856| 1857|465 1858|00:15:49,040 --> 00:15:53,120 1859|sake isn't helpful. Many people spend 1860| 1861|466 1862|00:15:51,600 --> 00:15:55,199 1863|too much time thinking about how to 1864| 1865|467 1866|00:15:53,120 --> 00:15:56,639 1867|perly optimize their system and not 1868| 1869|468 1870|00:15:55,199 --> 00:15:58,720 1871|nearly enough asking if they're working 1872| 1873|469 1874|00:15:56,639 --> 00:16:00,639 1875|on the right problems. Doesn't matter 1876| 1877|470 1878|00:15:58,720 --> 00:16:02,480 1879|what system you use or if you squeeze 1880| 1881|471 1882|00:16:00,639 --> 00:16:04,000 1883|out every second if you're working on 1884| 1885|472 1886|00:16:02,480 --> 00:16:06,320 1887|the wrong thing. And I think that gets 1888| 1889|473 1890|00:16:04,000 --> 00:16:07,759 1891|to the heart of it. Spend a lot of time 1892| 1893|474 1894|00:16:06,320 --> 00:16:09,120 1895|figuring out what matters. That's not an 1896| 1897|475 1898|00:16:07,759 --> 00:16:10,800 1899|easy question. But once you've answered 1900| 1901|476 1902|00:16:09,120 --> 00:16:12,720 1903|it, spend a lot of time working on that 1904| 1905|477 1906|00:16:10,800 --> 00:16:14,800 1907|thing and do your best with whatever 1908| 1909|478 1910|00:16:12,720 --> 00:16:15,920 1911|else and that'll work itself out. Don't 1912| 1913|479 1914|00:16:14,800 --> 00:16:18,240 1915|stress yourself out too much. It's 1916| 1917|480 1918|00:16:15,920 --> 00:16:19,600 1919|impossible to do it all anyways. But 1920| 1921|481 1922|00:16:18,240 --> 00:16:21,120 1923|working hard on the right thing 1924| 1925|482 1926|00:16:19,600 --> 00:16:23,440 1927|consistently, that's what matters. 1928| 1929|483 1930|00:16:21,120 --> 00:16:24,800 1931|Everything else is just trying to take 1932| 1933|484 1934|00:16:23,440 --> 00:16:26,560 1935|care of the details that are trying to 1936| 1937|485 1938|00:16:24,800 --> 00:16:27,519 1939|get in the way of that. Great way of 1940| 1941|486 1942|00:16:26,560 --> 00:16:29,920 1943|thinking about. So, you need some 1944| 1945|487 1946|00:16:27,519 --> 00:16:31,279 1947|systems and some rules, but mainly you 1948| 1949|488 1950|00:16:29,920 --> 00:16:32,399 1951|just have to do the work of finding what 1952| 1953|489 1954|00:16:31,279 --> 00:16:34,000 1955|to work on and putting in the right 1956| 1957|490 1958|00:16:32,399 --> 00:16:37,040 1959|time. 1960| 1961|491 1962|00:16:34,000 --> 00:16:38,320 1963|I wonder he probably his rules probably 1964| 1965|492 1966|00:16:37,040 --> 00:16:39,440 1967|have changed by now just because that 1968| 1969|493 1970|00:16:38,320 --> 00:16:41,440 1971|companyy's so large 1972| 1973|494 1974|00:16:39,440 --> 00:16:43,440 1975|>> and he's a lot richer. 1976| 1977|495 1978|00:16:41,440 --> 00:16:44,959 1979|>> Yeah, he is a lot richer. Um 1980| 1981|496 1982|00:16:43,440 --> 00:16:46,000 1983|>> I don't know if that changes. 1984| 1985|497 1986|00:16:44,959 --> 00:16:48,079 1987|>> That's true. But I'm just thinking like 1988| 1989|498 1990|00:16:46,000 --> 00:16:48,399 1991|the size of the company now versus then. 1992| 1993|499 1994|00:16:48,079 --> 00:16:49,600 1995|>> Yeah, 1996| 1997|500 1998|00:16:48,399 --> 00:16:52,399 1999|>> it' be interesting to check in. I think 2000| 2001|501 2002|00:16:49,600 --> 00:16:55,920 2003|now he probably is is all meetings. Um 2004| 2005|502 2006|00:16:52,399 --> 00:16:57,360 2007|I've never met Sam Alman, but busy guy. 2008| 2009|503 2010|00:16:55,920 --> 00:17:01,440 2011|Hey, if you like this video, I think 2012| 2013|504 2014|00:16:57,360 --> 00:17:01,440 2015|you'll really like this one as well. </file-view>

Summary: Sam Altman’s Forgotten Essay About How to Be Productive (Cal Newport, 17:00)

Cal Newport analyzes Sam Altman’s 2018 essay “Productivity,” written when OpenAI was at a pivotal turning point (just after GPT-1 and Elon Musk’s departure from the board). Newport pulls out five ideas from the essay and offers his own commentary, much of which aligns with his books Deep Work and Slow Productivity.

1. Compound growth in productivity

Altman argues that small daily productivity gains compound massively over a career. Newport is skeptical: getting 1% better every day is not truly exponential because skill acquisition slows as you advance. And “getting 10% more done” often just produces busyness, not important results. Historically productive figures like Newton, Galileo, and Jane Austen were often slow and deliberate rather than incrementally faster.

2. Picking the right thing to work on

Newport strongly agrees with Altman here. Altman wrote: “It doesn’t matter how fast you move if it’s in a worthless direction.” He protected time to read, talk to interesting people, and spend time in nature to figure out what mattered. Newport echoes this with his own advice: “Don’t get started.” Resist jumping into projects too early; wait until you can’t avoid them, then do fewer things better.

3. Use simple lists

Altman kept year/month/day lists, didn’t bother with complex categorization, and just starred especially important items. Newport praises this as “full capture”—externalizing tasks so your brain isn’t a storage device. However, he notes that people with many unavoidable obligations (emails, administrative tasks, students, etc.) may need a more structured task system. The core lesson remains: make sure something important gets done each day.

4. Ruthlessly say no

Altman said he was terse to the point of rudeness in email replies and avoided meetings and conferences because their time cost was huge. Newport endorses this, emphasizing that most demands on your time don’t matter; the valuable work is usually small, hard, and requires relentless focus.

5. Protect your mornings

Altman blocked his mornings—his most productive hours—for important work and scheduled meetings in the afternoon. Newport calls this a simple but powerful rule, noting that even a former president of a large company found protecting morning work time made him a much better executive.

Closing takeaway

Newport ends with Altman’s warning against “productivity porn”: optimizing systems for their own sake is useless if you’re working on the wrong problems. The real formula is:

Spend lots of time figuring out what matters.
Work hard and consistently on that.
Handle everything else as well as you can, but don’t let it steal focus.

Newport concludes that Altman’s 2018 advice is largely “non-surprising” but effective: it’s essentially deep work and slow productivity dressed in startup-founder language.