#optimization

• Prefer accessing memory sequentially. CPU access to RAM and cache is optimized for this.
• Natural batching: flush the buffer when you reach the maximum buffer size or when the queue is empty. This avoids buffers waiting unnecessarily.

• Knowing what you want is a valuable skill.
• Wanting things others will also want is valuable.
• Learn good software management. It is similar to managing agents.

gsettings set org.gnome.desktop.interface enable-animations false
gsettings set org.gnome.desktop.interface cursor-blink false
gsettings set org.gnome.settings-daemon.plugins.power idle-dim true
gsettings set org.gnome.desktop.notifications show-in-lock-screen false
gsettings set org.gnome.desktop.session idle-delay 300
gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-battery-timeout 900
# gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-ac-timeout 1200
```cd ~

• Ensure ownership of outcomes. Who owns increased checkout conversion rate? Payments, engineering, marketing, product, or UX? You may instead need small cross-functional activation, engagement, and retention teams. PM, designer engineer.
• Validate that outcomes lead to impact. This can be slow, and attribution is hard, but is important to continuously validate.
• Outcome change takes months, not weeks. So sprint using Now/Next/Later later roadmaps. As you learn, re-prioritize outcomes.
• Stakeholders want specificity. So quantify outcomes (+10% conversion) and timeframes (in 6 months).
• Stop experimenting and ship when you've validated the opportunity (customers need really connects to outcome) AND solution (feature really improves outcome). This is Torres' Opportunity Solution Tree (OST).
• Change incrementally. If you're running a feature backlog, continue. Add an "outcome hypothesis" field to each feature and create evidence.

• Look for single decisions that remove hundreds of other decisions. Peter Drucker via Jim Collins. E.g. Work only on LLMs, no new books this year, ...
• Derek Sivers:
  • Simple is not easy. Interdependency is complexity. Assets are dependencies. Accumulating information, purchases, employees/helpers, relations, etc. adds dependency. That makes life harder, challenges identity. Interdependency may be desirable - but reduce it in specific areas, to specific extents, temporarily, etc. Question every assumption: "Do you really need it?"
  • Here are some examples for me to try
  • Derek Sivers has no monthly payments (including income) or receipts (no subscriptions) at all! His code has no external code dependencies at all, and is building a house from scratch.
• Seth Godin:
  • Know WHO it (whatever you're doing) is for. Focus ONLY on that audience. Did it matter to them? Ignore the bad feedback from the person it was never intended for.
  • Never exceed a budget or deadline. When either runs out, you are done.
  • Treat any Yes/No you say as FINAL.
  • Skip meetings where a memo will suffice.

• Fine-tuning helps when:
  • Lower latency, e.g. for type-ahead, at lower cost (37 mentions)
  • Structured extraction, parsing and classifiers, e.g. postal address, detecting secrets (18 mentions)
  • Custom vision models, e.g. check containers (12 mentions)
  • Domain-specific code and stacks (niche languages, stack-specific generation, text→SQL) (11 mentions)
  • ... and a long tail.
• Fine tuning does not help:
  • When A base model plus prompting or RAG does as well or better (15 mentions)
  • When you risk being leapfrogged by a new release (4 mentions)
  • When cost and data do not justify the ROI (3 mentions)

• Delegation: context engineering agents for success; parallelizing.
• Verification: efficiently reviewing and testing code/output; setting stop-points.
• Expanding scope: instead of time saved as the metric.
• Education: teaching AI-based coding, debugging, reviewing/testing.
• Product management: combining requirements + UI design + architecture + engineering + deployment.
• Cross-discipline: blending code with design, governance, finance, marketing, ... ("computational creators").

• Open with a specific curiosity gap in the first 1-2 seconds. Give viewers a concrete unanswered question or visually odd setup ("Why is the coffee floating?") so the brain needs to resolve it. This is supported by short-video best-practice (hook early) and the "information-gap" theory of curiosity. Prompt tip: Start with one line that states the unresolved situation, then specify the exact first frame
• Use a 3-beat micro-arc (setup > build > payoff) sized for 6-20s. Don't cram a film; deliver one story beat every few seconds. The YouTube/Think with Google ABCD work (Attract, Brand, Connect, Direct) shows simple, purposeful structures outperform meandering ones-especially at bumper-ad lengths. Prompt tip: Add a tiny beat sheet with timestamps: "0-2s setup, 2-6s escalation, 6-8s payoff."
• Design the last moment first (Peak-End). Viewers remember the high point and the ending more than the duration; plan a twist, reveal, or "aha" and cut right after it. This is the Peak-End rule from psychology; in practice you'll see it as spikes near the end in retention graphs. Prompt tip: Write the final shot first; ensure the last frame resolves the opening question
• Pace with micro-beats and pattern interrupts. Change something every 1-2s (camera angle, scale, color, motion, prop) to reset attention without chaos. Platform guides stress tight pacing and clear structure for mobile attention windows. Prompt tip: List planned interrupts: "1. whip-pan, 2. hard cut to macro, 3. foreground object crosses lens."
• Max processing fluency: big, high-contrast, simple frames. The brain rewards "easy to process" visuals (clear figure/ground, symmetry, repetition)-they feel better and read faster on a phone. Keep one subject per shot; use bold contrast; minimal text. Prompt tip: Specify composition ("tight medium on subject, high contrast rim-light, uncluttered background, single color accent")
• Constrain on purpose: one change, one location, one idea. Constraints raise creativity and clarity. Micro-budget directing advice and 6-second ad research converge: pick one surprising constraint and lean into it. Prompt tip: State the constraint up top ("single hallway; only practical light; one prop changes form")
• Exploit visual salience and motion immediately. High-salience elements (faces, movement, contrast) pull gaze fast-vital on scroll feeds. Start with motion crossing the frame or a face entering; cut on action. Prompt tip: "Frame opens mid-action; subject crosses left>right; parallax background; quick dolly-in."
• Make sound part of the story, not wallpaper. Sync cuts to beats, use distinct diegetic sounds (whoosh, click, crunch) as transitions, and specify audio intent in the prompt. Veo's guide explicitly recommends fusing visuals with sound design. Prompt tip: Include an "Audio" block ("quiet street > sudden clack > riser swell; cut on snare")
• Direct the model like a DP: shot grammar in the prompt. With Sora/Veo you get better control when you name the lens, camera move, lighting, and blocking-and outline complex action step-by-step. Veo shows gains from highly detailed, play-by-play prompts; Sora exposes a storyboard interface for frame-accurate control. Prompt tip: "35mm lens, handheld, subtle breathing; golden-hour backlight; beat-by-beat action list."
• Iterate on retention, not vibes. Use YouTube's "Key moments for audience retention" to find spikes/dips; move top moments earlier, trim dips, and test a few alt cuts. Shorts auto-loop and rewatch spikes often correlate with a strong twist/payoff. Prompt tip: After v1, generate two alternates: (A) earlier reveal, (B) tighter mid-beat; compare retention

• Multi-agent systems are like organizations that can do more than a single human.
• Multi-agent systems conserve the context window.
• The top 3 drivers of performance variance: spending more tokens, more tool calls, better models
• You need to teach (prompt) the orchestrator how to delegate to sub-agents
  • How to avoid task duplication among agents
  • How many sub-agents to spin up for different kinds of tasks
  • Which tools to use for what
  • Provide sub-agents objective, output format, tools/sources, clear task boundaries
• ⭐ Self-improving agents, e.g. prompt optimizers or tool-testing agents that run and rewrite tool descriptions, are powerful
• Since agents are stateful, resuming from failure is important.
• Agent prompts are public

• State time boundaries. "We have 20 min. If we spend 5 min on your question, we'll have 15 for solutions."
• Clarify intent upfront. "Before we dive in: What can I help with?"
• Interrupt, summarize, clarify early. "Cooperative interruptions" are seen as supportive. E.g. "I get this: six accelerators, two done. Great! What can I help with? To accelerate?"

1. Be precise and avoid conflicting information. Use a prompt optimizer to check for inconsistencies.
2. Use the right reasoning effort. Prefer medium or low reasoning to avoid overthinking simple problems.
3. Use XML-like syntax to help structure instructions
4. Avoid overly firm language, e.g. "You MUST be THOROUGH" vs "Thoroughly".
5. Give room for planning and self-reflection. Explain what to do in steps, asking it to think deeply
6. Control the eagerness of your coding agent, e.g. do not ask for confirmation, parallelize tool calls, use more tools, etc.

• Built an intelligent tutoring system
• Encourage students to create their own pattern banks / cheat sheets. "Find 2 more problems that can be solved in the same way."
• Focusing on the problem-solving process shrinks the gap. Students above the 50th percentile of pre-assessment did not improve much. The lowest percentile improved the most.
• "At NUS, I know that even if I give 0.5% weightage for students attending tutorials, everyone will attend it for those 'free marks'."

• Ask PMs who know what users want
• Ask PMs again after sharing log analysis and survey analysis with them
• Automate via LLMs to scale backlogs

• With coding, it's testing, reviewing, deploying, use-case identification.

• Increase clarity, providing step-by-step instructions.
• Resolve conflicting instructions.
• Expand instructions to cover all scenarios and edge cases.

• Streaming. High impact, low effort.
• Caching RAG retrieval as well as generation. High impact, low effort.
• UI tweaks. Loading / streaming icons and progress hints ()"Retrieving context", "Generating answer", etc.)
• Parallelize, if possible
• Use model options where available, e.g. speculative decoding, models with higher speed, models with closer CDN, etc.
• Shorten prompts
• Persistent HTTP/2 Keep-Alive. Low impact, low effort (tweak server settings).

• The A* algorithm finds the shortest path in a graph much quicker than others like Dijkstra's algorithm by preferring nodes closer to the goal.
• Spatial Hash Indexing are O(1) and beat Tree Data Structures which are O(log n). Always prefer hashes when possible.

• Remove redundant tags and attributes (e.g. accessibility, etc.). Explore readability.
• Add a unique gid to each element.
• Add the screenshot WITH a "Set of Marks" - "SoM" (read research paper) highlighting important clickable elements.
• Code output is brittle. Use tools / DSL - e.g. visit_url(url), click_element(text, gid, tagName), etc.

• Agents make multiple LLM calls. Errors accumulate. So the quality of the model is key
• What's really critical: data + context + user preference
• Set up evals for subjective responses by collecting signals continuously.
• Create scaffolding for agents where errors don't accumulate. Better yet, make it FIX errors
• UX is critical. We need lots more UX styles

• Extending that thought, ANYONE who leverages assets through holistic thinking, becomes FAR more effective.

• Ask better questions. (Prompt engineering.)
• Create templates or step-by-step instructions. (Chain of Thought.)
• Ask for multiple options and pick from the best options. (Agentic approach?)
• Training. (Fine tuning.)
• Price weaker responses lower. (Stratified model pricing?)

• PRAGMA journal_mode = WAL. Improves performance for frequent writes. It allows concurrent reads and writes.
• PRAGMA synchronous = NORMAL. Improves performance. We might lose a few transactions but won't corrupt the database.
• PRAGMA mmap_size = 128000000. Set global memory map for processes to share data
• PRAGMA journal_size_limit = 64000000. Limit WAL file to prevent unlimited growth
• BEGIN IMMEDIATE instead of BEGIN. Prevents writes to the journal file until the transaction is complete. Improves concurrency.

• This works particularly well for verifiable results (code, math, etc.)
• Technique: Ask an LLM hundreds of times at low temperature and pick the most common one. (Google's Minerva used this on the MATH dataset.)
• Better Technique: Ask an LLM hundreds of times. Pick the best solution based on an evaluation metric (reward model)
• Better Technique: Apply a reward model at EACH step of the process. OpenAI's "Let's Verify Step by Step"

• Rouge 2 and Bleu and such metrics are NOT good. Create you own benchmarks
• Non-PEFT fine tuning needs 6X GPU RAM. Optimizer states, Gradient, Activations are the overhead. PEFT is about tuning a subset of parameters.
• LORA adds additional weights without updating the model. It's a low rank matrix multiplication. You can change these adapters in runtime. Saves space. Fast to train
• Quantization: Stick to bitsandbytes or AWQ (may be a bit better)
• QLORA = Quantization + LORA
• Predibase has open-sourced Lora Adapters in "Lora Land". Existing adapters are pretty good.
  • ghcr.io/predibase/lorax:main Docker image works on Docker compose to run locally. devices: on Docker Compose lets you specify NVIDIA GPU devices
  • Locust is a HTTP load testing lib in Python
• Techniques for inference optimization
  • Dynamic adapters: Loads right LORAX adapters WHEN a request comes in
  • Multi-adapter batching: Process all inputs in parallel on the same GPU, but different users are post-processed using different adapters

• Defensive UX: Microsoft, Google, and Apple have guidelines for Human-AI interactions
• Collect feedback: Explicit and implicit

• solve your own problem. Don't solve other people's problems. This helps you pick what you're good at
• affordable losses. Make sure you survive
• borrow others' spares. spare time, scrap data, anything others don't use. If you can monetize it, you can pay them back
• focus on the controllable. Ignore what's outside your control don't even waste time on it

• Humans have a bias against inaction. Hence a strategic advantage. What can you cancel today?
• Humans have a bias against subtraction or removal. That too is a strategic advantage. What can you remove today?
• Humans have a bias against constraints. That's a strategic advantage. What constraint can you embrace?
• No Yay! When declining something, add it your calendar so that when the time comes you can say yeah I got this time back