#github

1. Phishing the author
2. Pull requests running unsafe code in CI
3. Taking over expired domain / user ID
4. Stealing long-lived tokens

• Ask user (for clarifications)
• Internet tools
  • Search
  • Fetch (CORS-piercing)
  • Scraper with XPath/CSS Selectors
  • Access to llms.txt
• LLM APIs
  • Summarizer (condenses chat)
  • Sub-agents
• Coding tools
  • Markdown convertor
  • Code execution (including tests)
  • Browser + DevTools for testing
• Memory / storage
• Tool/MCP directory with search

const branch = await $`git branch --show-current`;
await $`dep deploy --branch=${branch}`;

• ChatGPT suggested increasing observability based on code reviews. I'm including it in my weekly codecast.
• ChatGPT suggested defining closures inmeetings. I'mn now discussing objectives at meeting starts and effectiveness at the end.

• It can run a terminal in its own new window for over a year (via Ctrl+P > Terminal: Move Terminal into New Window). Now, Ctrl + Alt + Shift + ` does this directly.
• Terminal Intellisense shows completion suggestions in the UI. Very helpful. Ctrl+Space triggers the menu completion.

• Use standards. Or, write your standards in README.md and tell AGENTS.md / CLAUDE.md to read it.
  • Use a standard file structure. Or in README.md, list what each file is for. Helps agents pick the right file for context.
  • Use a standard build/lint/test setup (e.g. package.json scripts). Or
• Localize context, i.e. add context in files that use them. E.g. add comments in test files on how to execute them.
• Keep files modular so agents can read less code and conserver context.
• Write a developer's guide.
  • Use with /init in Claude Code / Codex / ... or have an LLM generate a developer guide.
  • Edit manually. Agents don't write great specs.
  • Document the design.
  • Write DETAILED specs to reduce deviations.
• Share goal while specifying tasks. Helps agents fix related stuff.
• Use deep reasoning mode, e.g. "think harder" or "ultrathink" in Claude Code, or -c model_reasoning_effort=high in Codex.
• ⭐ Run parallel agents in different windows and share agent feedback with each other. E.g.
  • Server/API coding in one window. Client coding in another.
  • Plan/ask in one window. Execute in another.
• Add debug logs to help agents spot errors.
  • Start/stop of long/complex operations, state changes, external interfaces.
  • Include full objects in logs. Prioritize diffs. Trim long contents.
  • ⭐ Give access to debugger, e.g. Chrome remote debugging at localhost:9222
• Agents write poor tests. So:
  • Manually add important ones.
  • ⭐ When you find a bug, ask the agent why the tests missed it and have it add.
  • Review and remove useless ones.
• Ensure agent passes test cases. Tell them not to disable / skip failed tests.
• Have agents create a new branch per feature and auto-commit. Merge when successful.
• Feel free to provide a TODO list or update it on the fly.
• Interrupt with Esc if the agent's thinking is off-track.
• When agents struggle, write tools to help them, e.g. JSON splicing, Excel edits, etc.
• Agents bloat code and features. Explicitly refactor and trim.

• Use vibe coding for stuff you don't need to maintain.
• Use vibe coding for stuff you know well enough to review quickly.
• Use vibe coding for independent tasks where you're not fussed which ones fail.
• Vibe coding turns everyone into a team lead. That needs skills: planning, allocation, design, review, feedback, ...
• ⭐ Empathy enables vibe-coding. Empaths allocate work by ability, review regularly, and provide detailed specs and feedback.
• Have LLMs plan and allocate tasks.
  • "Read this repo. Suggest improvements." (Review.) "Add these as issues."
  • "Add the top 3 Sentry log errors as issues."
  • "Find the easiest issue and solve it with a PR."
• Use GitHub issues extensively for planning.
• ⭐ Create a separate GitHub account for your agent! Let it push. Assign it issues. Treat it like an intern.
• Ensure agent passes test cases and run till the do, or report the core difficulty.
• Throw away rubbish code and start again.
• Issues unsolved in 2-3 tries are too hard for agents or are poorly spec-ed.
• The context7 and Sequential Thinking MCPs are useful.

• VS Code plugin with remote container execution
• Drag & drop image support PR Docs
• Queued (editable) messages PR
• Web search via --search PR
• Esc-Esc to edit previous messages Docs

• Summarize takeaways on top of each section
• Use atomic notes: one file per idea. Link liberally
• YAML front-matter you can query, e.g. tags, project, status, ...
• Use GFM admonitions, e.g. > [!NOTE]
• Store images in a predictable way, e.g. ![Alt text](./img/2025-08-21-screenshot.webp) -- ALWAYS with alt text
• Use diff fences for edits / doc changes
• Task lists with inline dates, e.g. - [ ] 2025-08-21 Draft a letter

• Policy-as-code app. Checklist from doc. Apply checklist to data / doc inputs.
• Code similarity checker library based on TDS Project evals.

• Delete-Driven Development. Keep deleting code until it fails, then rebuild minimally.
• No-Editor Coding. Pure prompting to build, test, and deploy the app.
• Audience-Sourced Prompt ETF. Collect micro-prompts from audience. Run in parallel. Evaluate against tests. Create index of top prompts. Compare with expert.

• Commands are used for:
  • Requirements: Research sub-agent, task breakdown into todos.md, creating specs.md from todos.md
  • Progress tracking: session logging, effort tracking, updating status, planning next steps
  • Project setup: initializing, adding deps, scaffolding features
  • Development: code review, debug error (five whys), explain code, refactor code
  • Optimization: optimize build, DB, caching
  • Testing: TDD, generate test cases, set up unit/integration/E2E testing, analyze coverage
  • Security: security audits, dependency vulnerability scans
  • Integration: sync tasks between GitHub and Linear (two-way issue synchronization, PR linking)
  • Deployment: prepare releases, hotfix deploys, rollbacks, containerization, CI pipeline setup
• Patterns of usage
  • Sub-agents
  • Command handoffs, i.e. one command invoking another
  • Shared among a team in a repo, enforcing standards & sharing best practices
  • Integration with specific tools / APIs (e.g. Linear)

• Skip biomejs for now. It uses tabs (not spaces) and does not respect .gitignore by default. Handling these is too much work.

• Provide a stable, complete spec.
  • Late UI tweaks, new API params, renamed fields, extra packaging rules, “Rename per‑image download”, “standardise baseUrl vs baseURL”, “add GA‑4 exam module”. → churn & rewrites.
  • Ask the user for a final UI/API/mock‑up + edge‑case examples before the first commit.
  • Lock naming conventions, UI layout and feature checklist early; track future changes explicitly
• Include concrete examples.
  • Lack of sample images, Markdown snippets, question formats caused guesswork.
  • Supply mini‑fixtures: sample prompts, expected outputs, env‑var names, commit‑message template
• Environment should be reproducible.
  • E.g. vitest not installed, .dev.vars absent, sub‑modules not cloned, network blocks.
  • Ship a one‑step bootstrap script / README with npm install, env‑var templates, and submodule notes
• Automate tests.
  • First answer compiles but fails prettier/ruff/unit tests; later iterations fix style or red lines.
  • Codex should auto‑run lint && test (plus static‑analysis / self‑critique) before every response
• Auto-run post-mortems.
  • Codex recommending its own static checks shows value.
  • Automate that as a pre‑commit step.

• claude --debug shows what Claude Code is doing behind a scenes -- and is a good way to understand hidden / undocumented features.
• At the end of each session, ask Claude Code: "Document learnings. What failed? What worked? What's next?"
• Have Claude Code write its own prompts by having it launch sub-agents and create common commands in .claude/commands/.
• Symlink CLAUDE.md, AGENTS.md and GEMINI.md into a CONVENTIONS.md
• Prefer creating tools / writing scripts to analyze data and feed results -- reduces input tokens.

• Run with OpenRouter via OPENAI_BASE_URL=https://openrouter.ai/api/v1 OPENAI_API_KEY=$OPENROUTER_API_KEY OPENAI_MODEL=qwen/qwen3-coder npx -y @qwen-code/qwen-code
• Quality: not as good as Claude Code. When prompted to Move AI Image Chat position in tools.json AND in README.md to just below Daydream. Add a small filled-circle icon before "Created: ..." date. The color should be based on how old the created date was. Use primary if it's within the last week, success if it's in the last 30 days, warning if it's in the last 365 day and light otherwise. Also, add a col-xl-3 to the tools-grid cells
  • qwen-code + qwen-coder cost 8 cents and made 3 mistakes.
    • Copied instead of moving the demo
    • Did not render a filled-circle icon. It created an empty badge that ended up not being displayed
    • Did not add a col-xl-3 to the tools-grid cells
  • qwen-code + claude-sonnet-4 cost 104 cents and made no mistakes
  • claude-code cost 29 cents and made no mistakes

• Auditize: citations, rationale, output screens, diffs, test results, risks, unknowns
• Auto validate. Evals, tests
• Prioritize. High z-values, big-useful-surprising areas

To keep Claude Code in line on my project, I’ve relied heavily on linters, build scripts, formatters, and git commit hooks. It’s pretty easy to get Claude Code to commit often by including it in your CLAUDE.md, but it often likes to ignore other commands like “make sure the build doesn’t fail” and “fix any failing tests”. All my projects have a .git/hooks/pre-commit script that enforces project standards. The hook works really well to keep things in line.

• Claude 4 writes exhaustive professionally styled code but struggles over long conversations.
• Gemini 2.5 Pro produces working but “spaghetti” code.
• GPT 4.1 is fast and good, the go-to for usual coding tasks.
• Claude easily swings toward your style but Gemini is stubborn.
• GPT models tend to hallucinate more on bigger tasks.

• O3 is better at finding bugs than Jules, which tends to try and fix them rather than discover them.
• Codex writes more minimal edits in PRs than Jules, which is more verbose.
• Claude Code remains the best at faithfully creating and updating front-end apps.

• git worktree add -b $newbranch worktree/$path creates a copy of HEAD in $path as a $newbranch
• git push from branch and create a pull request
• git worktree remove worktree/$path to remove worktree
• git worktree prune for garbage collection

• GitHub Releases. 2 GiB per file, unlimited total & bandwidth. 🟢 Immortal URL, versioning, easy CI publish. 🔴 Each file must stay < 2 GiB; no built-in SQL.
• Zenodo (CERN). 50 GB per record; one-off bumps to 200 GB. 🟢 DOI assignment, archival mandate. 🔴 Occasional throttled bandwidth; no API for partial file reads.
• Hugging Face Hub. 300 GB per repo; 50 GB per file. 🟢 Git-based, dataset tooling, lively ML community. 🔴 Large files need git-LFS; pushes via LFS can be slow.
• Cloudflare R2. 10 GB storage & 1 M ops / month. 🟢 S3 API, zero-egress to Cloudflare Workers, fast. 🔴 10 GB cap below your 50 GB target.
• Kaggle Datasets. 20 GB per dataset, public only. 🟢 Built-in notebooks & GPU. 🔴 No programmatic SQL API; quotas sometimes change.
• data.world (free). 1 GB total, 100 MB per dataset. 🟢 Nice social features. 🔴 Too small for your size.

• HTML meta tags: <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate">
• Use a service worker (blog)
• Proxy through a CDN. Cloudflare, Netlify
• Move to another static host: S3 + CloudFront, Heroku, Vercel, Surge, Firebase Hosting

• Google Cloud Shell: Free for 50 hours/week, refreshed every Monday. Sessions last up to 12 hours and terminate after ~1 hour inactivity. Ref
• Azure Cloud Shell: Always free to use with 5 GB free storage for first 12 months (standard rates after). No documented session limits but typically times out after prolonged inactivity. Ref
• AWS Cloud9: Free IDE, underlying compute free under AWS Free Tier (750 hours/month EC2 t2.micro or t3.micro for first 12 months). Regular EC2 rates apply afterward. Ref
• Gitpod: Free tier offers 500 credits/month (~50 hrs). Workspaces run up to 8 hours/session and stop after 30 minutes inactivity. Ref
• GitHub Codespaces: 120 core-hours/month (~60 hrs with 2-core machine) and 15 GB storage free. Sessions timeout after 30 minutes inactivity. Ref
  • Create: gh codespace create --idle-timeout 10m --machine basicLinux32gb -R $USER/$REPO returns the $CONTAINER_ID
  • SSH: gh codespace ssh -c $CONTAINER_ID
  • Delete: gh codespace delete -c $CONTAINER_ID
• Replit: Free Starter plan provides 20 hours/month, 1 vCPU, 2 GB RAM, 2 GiB storage. Repls sleep after 30 minutes inactivity. Ref
• IBM Cloud Shell: Free for all users; 50 h/week per region; any open session counts toward quota; sessions can run any length up to weekly cap; 500 MB temporary workspace. Ref
• Oracle Cloud Infrastructure Cloud Shell: Free within tenancy limits; up to 400 h/month on Pay-As-You-Go, 240 h/month on Universal Credits; 5 GB encrypted persistent home. Ref
• PythonAnywhere: Free (beginner plan), includes one web app (restricted outbound), low CPU/bandwidth, no Jupyter; 2 concurrent Bash/Python consoles, 500 MB disk; limited daily CPU. Ref
• Glitch: Starter (free) plan -- full-stack apps sleep after 5 min inactivity and wake on request; unlimited public/private projects; container state preserved. Ref
• CodeSandbox: Free tier provides 400 credits/month (~40 h of 2 vCPU+4 GB Devbox runtime), unlimited front-end Sandboxes (no credits), up to 20 Sandboxes/workspace. Ref

• open-interpreter 59,274 ⭐ Apr 2025 AGPL-3.0. Lets an LLM write/run Python, JS, Shell, or Bash locally; can open a browser tab, edit files, plot data, or call any CLI tool. Works on macOS, Linux, Windows (plus Termux & Colab). Big community, plugin system, optional voice mode, and a desktop GUI in beta.
• cua 5,601 ⭐ May 2025 MIT. Spins up near-native macOS or Linux VMs on Apple-Silicon Macs (“Lume”) and exposes a vision+action API so any model can pilot the VM. Gives you GPU-accelerated isolation and reproducible sandboxes; ideal when you don’t want an agent touching your main OS.
• Operator (OpenAI) – closed-source research preview launched 23 Jan 2025. Runs a GPT-4o-powered “Computer-Using Agent” that sees web pages, clicks, scrolls, fills forms, and hands control back to the user when needed. Hosted in an OpenAI-managed Chromium sandbox, so it works from any OS with a browser. Safety layers require confirmation for payments and log-ins.
• Claude Computer Use – closed beta inside Claude 3.5 Sonnet (since late 2024). Developers get an API that streams screenshots and accepts mouse/keyboard actions, letting Claude automate GUI workflows inside a VM. Cross-platform; still experimental and slower than humans but first “general” computer-use feature from a foundation-model vendor.
• Agent-S 4,065 ⭐ May 2025 Apache-2.0. A “generalist-specialist” framework that chains specialist GUI skills under a planner. Scores SOTA on OSWorld/WebArena, supports macOS, Windows, Linux, Android via the companion gui-agents lib, and integrates memory/evaluation loops for continual learning.
• open-computer-use 1,094 ⭐ Mar 2025 Apache-2.0. Launches a secure Ubuntu desktop in E2B’s cloud sandbox, then orchestrates three LLM roles (grounding, vision, action). Streams the desktop to your browser and lets you pause/override at any time. Plug-in list of >10 models.
• surf 353 ⭐ May 2025 Apache-2.0. A polished Next.js front-end that wires OpenAI Operator-style agents to an E2B sandbox. Single command to boot a virtual desktop, chat, and watch the agent work. Good starter template for web-based CUAs.
• Pig – cloud service. Provides on-demand Windows 11 VMs and an API that exposes high-level GUI primitives (type, click, window focus). Targets RPA-style workloads; still alpha, but unique for Windows-first focus and low-latency streaming.
• gptme 3,767 ⭐ May 2025 MI. A terminal-first personal agent that can run shell commands, edit files, browse the web, and use local or cloud LLMs. Works on Linux, macOS, Windows; great when you want automation in the CLI rather than the GUI.
• langgraph-cua-py 143 ⭐ Mar 2025 MIT. Shows how to build a computer-use agent as a LangGraph state machine, defaulting to Ubuntu VMs from Scrapybara but swappable. Provides nodes for vision, memory, human-in-the-loop, and streaming.
• openmacro 101 ⭐ Oct 2024 MIT. Early-stage multimodal assistant that executes Python snippets locally via SambaNova models. Cross-platform CLI; profile system lets you switch API keys or tool sets. Inspired by OpenInterpreter but lighter weight.
• computer-agent 443 ⭐ Jan 2025 MIT. A PyQt desktop wrapper that lets Claude Computer Use drive your actual machine. Shows practical wiring from Anthropic’s API to local mouse/keyboard events; tested on Linux & Windows.

• Make quick edits to repos that are not on your system (e.g. other people's repos, or via others' machines.)
• Run public workshops with a full coding environment.
• Give students assignments that have dependencies pre-installed.
• Collaborate on a work-in-progress codebase with my team.
• Share POCs with clients or public allowing them to edit it.
• Allow teams to install remote AI code extensions (e.g. Windsurf) that may be blocked inside the corporate firewall?

• You can't run commands. Only prompts. You need to exit codex to run commands. So you can't use it like a shell, e.g. like Warp.dev.
• It doesn't index local code. It runs commands to figure out stuff.
• Code diffs and applying changes are clunky.
• The output is hard to read with text scrolling.
• codex.md can only handle 32K.

• GitHub Copilot can identify the source of a code snippet as a repo. That helps with copyright issues.
• Cursor uses a shadow workspace - a temporary sandbox where it edits files before applying changes at one shot.
• Cursor auto-complete has context of other files, i.e. inserting an class in a .js file based on another HTML file's contents.
• Windsurf seems to be best for large code bases and for large-scale refactoring. It can also run test results fix them.
• Windsurf includes a browser and lets you click on an element and prompt to change its behavior, etc. That's good for front-end developers.
• Roo Code can run scripts as part of the workflow, letting you run linting, tests, starting web apps, query databases, etc.
• Roo Code lets you create persona, e.g. code reviewer, data storytelling and analysis, etc. with access to different tools and behaviors.
• Roo Code does not support auto-complete.

• Recurse center (Brooklyn, online) is a 6/12 week free self-driven programmer retreat. Runs every 6 weeks. You can do whatever you pick. There are daily standups for accountability. The groups are diverse. You can pair with them, pivot ideas, whatever. Principles: push yourself & learn.
• Western education techniques (e.g. spaced repetition, adaptive learning) are very much present in Indian coaching systems, though not known by those names. However, interventions are hard since class 12 students just don't have enough time.
• Coaching classes are a social phenomenon. It's not the smart students who are pulling in their friends. Smart students actually follow the popular students. (Coaching classes are below the typical smart students' standards.)
• Monetizing coaching is hard. People don't want to pay for advice, and welcome free advice only if they ask for it. Coupling with execution is necessary.
• Aider's integrations make it more powerful than Cursor/Windsurf. It auto-lints, runs test cases. Allows different models for "architecting" (generating changes) vs "editing" (applying code). It reads from the screen logs. Context is manual, not automated. Uses an ai! comment to trigger changes and ai? to ask questions.
• Cline.bot is another Cursor-like open source AI code editor that's a VS Code plugin.
• When coding with LLMs, a useful workflow is: data schema ➡️ interfaces ➡️ LLM-generated test cases ➡️ code.
• ShellSage is a tmux based LLM tool for the command line. It screen-grabs from tmux, which is powerful.
• Some MCPs that have proven useful: vega-lite, SQLite, sequential thinking, memory
• make sucks but is hard to beat. just comes closest.
• CRDTs are more powerful than for just collaborative editing. It can power a peer-to-peer Internet (beginning with office tools). Versioning schema is still problematic. yjs is a good start but automerge (Rust, WASM) is faster and may be better.
• Fermyon hosts WASM serverless functions.

• I have 3 categories. Things I learnt, which I just note. Things to explore, which I can delegate, defer, drop, or do at any time. Things to do, which are the hardest and pile up.

• Here is the script that generated it.
• Note the use of NVIDIA's GPU Docker containers via nvcr.io

• Snowman is a browser-based Twine 2 story template format.
• These enable behavioural experimentation. Cheaper than using tools like Gorilla.sc and Pavlovia for behavioral experiments
• For example, you can present a social or political issue and see if people change their opinions more or less depending on the content/path they see. Or, if it varies by demographics. Or, check if repeated mentions or emotional hooks improve memory / retention. More research ideas

• The VS Code plugin makes development very easy
• Marp CLI makes deployment easy.
• I used it for my talk on LLM Hallucinations (source).
• Supports all bespoke features and plugins
• Transitions. Requires OS animation effects to be enabled
• Animated SVG backgrounds are a good add-on.

• Roo Code is open source. Available as a VS Code extension and run-nable via git clone
• Roo Code supports Computer Use. It can read files, take screenshots from a built-in browser, controls it, and reads browser console logs.
• Opinions are mixed. A team member reported that it takes 10 LLM queries to do what Cursor does in 2. Another reported that it does in 1 query what Cursor does in 2.

• Copy an entire issue (with history) from GitHub, Gitlab, or JIRA
• Copy an entire PR (with code changes) from GitHub, Gitlab, or Bitbucket
• Copy CI/CD logs from GitHub Actions, Gitlab CI, Azure DevOps, etc.
• Copy entire conversation thread in Gmail or Discourse, Service now etc.
• Copy product reviews from Amazon, Shopify, etc.
• Copy page(s) from wikis and content sites like Wikipedia, StackOverflow, etc.
• Copy survey responses from Google Forms, Typeform, etc.
• Copy all interactions with a contact (including interactions, proposal history) from HubSpot or Salesforce
• Copy transcripts from Zoom, Teams, Google Meet, etc.
• Copy as Markdown from Word, GDocs, PDF or HTML
• Copy the summary of an analysis as well as all key metrics from any dashboard
• Copy SAP invoices
• Copy JDs, CVs, and reviews from Workday, BambooHR, DarwinBox, etc.
• Copy design specs, component libraries, and style guides from Figma, Miro, etc.
• Generated with the help of ChatGPT -- link not working

• Marker from DataLab seems comparable but is CC-BY-NC-SA.
• MinerU convert medical textbooks to Markdown well.
• Gemini Flash may be more cost effective and better

• Autocomplete and tab completion works perfectly, out-of-box.
• Syntax highlighting is beautiful
• Great multi-line editing

• git pull --recurse-submodules: Pulls parent repo along with submodules
• git submodule status: For each submodule, show current commit, path, and branch (if on a branch)
• git submodule update --init --recursive: Fetches/moves each submodule to the commit tracked by the parent repo

• uvx files-to-prompt
• npx git-ingest
• ingest - written in Go, only Mac/Linux binaries

• AgentRun: open source, via Docker
• e2b.dev: A day costs about $1 (on demand) and you get about $100 one time credits. Self-hosting is complex. Discussion
• nsjail: by Google. Write your own API

• Passing code execution as a tool is more powerful than granular tools. You combine multiple tools and tool calls into one. You move code to the data rather than the other way around. Mostly, you need bash, Python (or Jupyter), file manager, web browser.
• UI: Go where the user is, instead of bringing them to you.
• A remote runtime is a critical component.
• Claude 3.5 Sonnet (20241022) and Claude 3.5 Haiku (20241022) perform best on SWE Bench, followed by Deepseek V3, then O1 2024-12-17. X

• GitHub Pages: Static websites, medium files
• Cloudflare Pages: Static websites, global delivery
• Vercel: Frontend frameworks (e.g. Next.js) with high DX and ISR, small files
• Netlify: JAMstack projects, minimal back-end, moderate files
• Glitch: Small static projects
• Render: Full-stack apps requiring databases and server-side compute
• Firebase Hosting: Small sites, limited large files
• Archive.org: Public archival, large files
• Google Drive: File sharing, large files
• Dropbox: File sharing, moderate files
• Cloudflare R2: Static assets, large file delivery

• Jekyll - Ruby - 2008
• MkDocs - Python - 2014
• GitBook - JavaScript (Node.js) - 2014
• MkDocs Material - Python (MkDocs-based) - 2016
• Docsify - JavaScript - 2016
• MdBook - Rust - 2017
• Antora - JavaScript (Node.js) - 2017
• Docusaurus - JavaScript (React) - 2017
• JupyterBook - Python - 2019
• Keenwrite - Java - ~2019
• Honkit - JavaScript (GitBook fork) - 2019
• Nextra - JavaScript (Next.js) - 2020
• Astro - JavaScript/TypeScript - 2021
• Hugo Book - Go (Hugo-based) - ~2020
• Clowncar - JavaScript/Node.js - ~2021
• Quarto - R and Python - 2022
• Starlight - JavaScript/TypeScript - 2023

• Automate changelogs for your codebases. Convert past commits into attractive release notes automatically
• AI is going to be the consumer of many tools and logs. Build converters for these
• Speed of validation such as linting, testing, etc. will allow LLMs to iterate faster and WILL become more important

• Github Copilot
• Cursor
• Cody
• Continue.dev (supports OpenRouter)
• Aider (supports OpenRouter)
• Maybe:
  • Codeium
• Not:
  • Amazon Q Developer

• o1-preview > claude-3.5 sonnet on code editing
• claude-3-opus > claude-3.5-sonnet on code refactoring
• deepseek-coder-v
• gpt-4o-mini sucks.

• Vaishnavi and Ranjeet edited code
• Indal and Koustav didn't

• Always add screenshots to the Readme. They never break.
• Always add every example. Human think in examples.
• Avoid defaults and be explicit unless 99% of the usage is with the default.
• Make the feedback loops incredibly fast.
• Make deprecations easy for users to deal with.
• Keep objects immutable.

• At Khan Academy, every developer working on Khanmigo has cursor. Everyone who's contributed to a Khan Academy GitHub repo has GitHub Copilot.
• I stopped using Google + StackOverflow 2 years ago. I use ChatGPT, Copilot, etc. For humans, I ask Reddit.
• Excited by async agents. Things that do my job while I sleep.
  • Zapier notifications.
  • Monitor what happens. Put it into a flow diagram and alert me.
  • Every month, did my broker trade? Did my bank transaction fail? Did I pay my electricity bill?
  • Every time you delegate, use an agent instead.
  • Read my RSS feeds.
  • Read my browser history and suggest interests.
• Plan a session in Bain, BCG, etc. on Artifacts.
• Explore sparse embeddings. More effective. ColiPali, ColBERT

• Cognition
• Factory
• Codegen

• Write tests that make people think! Like DuckDB workshop
• Share a list of exercises that people can explore

• Select any code and command Explain this to understand the code
• %something in command bar searches ACROSS files for a term. Exactly like Ctrl+Shift+F
• Copilot has an Inline Chat: Start in Terminal (that needed me to unbind Ctrl+I in bash to work)
• Ctrl+2 opens a second window on the side. Ctrl+1 goes back to the first window
• Terminal: Open Detected Link lets you scroll through detected (file) links in terminal
• Terminal sticky scroll is transparent. (But Terminal stick scroll isn't working for me.)
• Copilot uses last 10 commit messages, Jupyter notebook kernel state (variables) as additional context
• 1.88: supports locked scrolling to sync scrolling of side-by-side windows

• GitOps
• Internal Developer Platform
• Graph Data Science
• Open Source Program Office
• Value Stream Management Platforms

• Advent of Gen AI is going on. Explore
• add to tools in data science course. Model validation
• write a book as an open source to github repository. Easier to evolve and easier to get feedback on..
• Explore utterances as a GitHub commenting platform
• automatically give credits to contributors who have center pull request that was accepted or an issue that was fixed. This encourages contribution
• Visit book.premai.io