Forgebitz points to Promptwatch as a way to observe website citations in ChatGPT answers. The post draws attention to visibility that may not produce a conventional search click.
Pocket note
Keep a small set of questions your audience might ask an AI, then record which pages get cited and when. This bookmark points at visibility that a normal click report can miss. Useful signal to compare with actual inquiries.
Ege shares a structured image prompt for a DualSense controller with compact cactus thumbsticks. The instructions preserve the familiar product geometry while concentrating the surreal change in one functional detail.
Pocket note
Keep the familiar object intact and make one point of contact deeply wrong. The cactus thumbsticks do all the work here. Borrow the move: change the material where a hand would go, then let the product photo stay completely straight-faced.
Daniel San raises a skill-maintenance concern: provenance and upkeep comments can add irrelevant material to the agent's context. The post links a feature request exploring ways to distinguish human-facing annotations.
Pocket note
Give the skill’s maintenance history its own home. Dates to revisit, provenance and housekeeping notes can sit beside the instructions instead of interrupting them. Keep the operating file focused on what the agent needs during this task.
Ege shares a fashion-editorial prompt pairing a model with an oversized sneaker held overhead. The brief ties the worn shoes and enlarged product to the same reference and specifies contact, lighting, and framing.
Pocket note
The giant sneaker needs something to rest on: hands that grip it, a pose that carries its weight, shadows where things touch. Use the same product reference for both sizes. Those physical relationships sell the absurd scale.
Bearly AI summarizes an argument attributed to Instagram's Adam Mosseri about synthetic media, originality, and creator trust. The post discusses source credibility and media provenance alongside visual aesthetics.
Pocket note
A shaky camera and a messy desk can be generated too. The interesting shift in this summary is toward who made a thing and what context comes with it. Looking candid and earning trust are different jobs.
CloudAI-X introduces its claude-workflow repository as a package of specialized agents, skills, and hooks. The post includes a local plugin-loading example.
Pocket note
A reusable cast of reviewers, debuggers and auditors is handy when each has a distinct job. Start with one role and ask for findings tied to actual code and a reproducible problem. Then see whether another role adds anything useful.
Mike Futia describes a Gemini Gem that reviews home, product-listing, product-detail, and cart screenshots. Its proposed outputs include a friction log and an experiment roadmap.
Pocket note
Capture the same shopping trip across home, product listing, product page and cart. Ask where the promise or next action changes unexpectedly. Turn one visible inconsistency into a test; the screenshots give you a hypothesis to investigate.
Emily shares a detailed image-generation prompt for converting supplied material into a photographed whiteboard scene. It separates content fidelity, board layout, handwriting, color roles, and subtle signs of previous use.
Pocket note
Give the board a lesson plan before giving it smudges. Organize your source into three clear blocks, choose one diagram, then add the photographed-whiteboard texture. Emily’s prompt gets its character from the residue without letting the old marks bury the new idea.
Hasan Toor collects ten public learning repositories, including Hands-On Large Language Models, Microsoft's agent course, Made With ML, and the Prompt Engineering Guide. The list spans model fundamentals, agent examples, and production concerns.
Pocket note
Pick the repo that answers the question blocking your project. Run one example, change something, and keep the result. Ten excellent repositories can otherwise become ten more tabs waiting for the mythical weekend when you study everything.
Frank DeGods suggests giving a coding agent the full idea and explicitly inviting clarification through multiple-choice questions. The post focuses on exposing gaps before implementation.
Pocket note
Before the build, ask the agent for the three unanswered decisions most likely to change it. Request a couple of options and their consequences. Answer those, then start. Frank’s suggestion gives a rough idea a useful interrogation.
Pratham proposes learning programming through a personally useful project, then asking an AI tutor to explain the generated implementation. The post emphasizes understanding the code instead of merely accepting it.
Pocket note
Have the agent build a tiny app you want, then trace one interaction from click to result. Explain it back, change a requirement, and predict which code should move. That second pass is where the little app becomes a lesson.
Greg Isenberg describes trying Alibaba's Accio and links an episode about the experience. He highlights a proposed workflow connecting review analysis, product concepts, and supplier discovery.
Pocket note
Start the product brief with a recurring complaint. Turn it into a specific change in the handle, material, dimensions or packaging, then investigate suppliers. Isenberg’s Accio example is interesting because it connects the complaint to something someone could actually make.
Andrej Karpathy reflects on using coding agents extensively, including wrong assumptions, excessive abstraction, and the need to review changes. He recommends defining success criteria and giving agents a way to check their work.
Pocket note
Give the agent a finish line it can inspect: a failing test, a working browser interaction, or the same answer computed faster. Karpathy’s useful move is letting that check drive the loop. Keep the actual result open beside the conversation.
Rabin describes his public personal-assistant setup: research and asset workflows, context files, a decision log, and session closeouts. His emphasis is on skills that perform work through tools and preserve continuity.
Pocket note
A skill gets much more interesting when it calls a tool and leaves an artifact: a sourced brief, an image, a decision record. Add a clean handoff at the end so tomorrow’s session can pick up the work without reconstructing today.
Rabin introduces a public test version of Swarma, describing work built around Hermes, agent swarms, and QMD. The post explicitly says users must configure and run it themselves.
Pocket note
Start an agent experiment with a hypothesis and a decision rule: what would make you keep going, change direction or stop? That’s the useful shape underneath Swarma’s growth loop. A busy swarm still needs a question to answer.
Jeffrey Emanuel describes using the fff.nvim project as an optimization reference for his own search library. He invites examples of code that makes deliberate use of modern hardware.
Pocket note
Give the agent a genuinely fast implementation to study. Ask for three techniques it could transfer to your slow operation, with the source files attached. Try one, measure it, keep the correctness checks. The reference doesn’t need to use your language.
Rabin's public Swarma v0.2.0 post describes the tension between fast personal experiments and a release other people can use. He identifies the release as a test version and lists setup tooling, skills, and shared playbooks as planned work.
Pocket note
The messy version on your machine can run on knowledge that only you have. A public release has to carry that knowledge with it. This Swarma update captures the point where installation, examples and known bugs become part of the work.
Andrej Karpathy describes his own workflow for turning raw sources into a linked Markdown wiki maintained by an LLM. He uses Obsidian to inspect the collection and files useful query outputs back into it.
Pocket note
Keep the raw sources, let the agent build linked notes, then save the good answers back into the wiki. The lovely loop here is that a research session leaves something behind for the next one to build on.
Andrej Karpathy shares a gist describing an LLM-maintained wiki and proposes sharing the underlying idea so other people's agents can adapt it. He deliberately leaves implementation choices open.
Pocket note
Share the behavior you want, a worked example and the boundaries. Let someone else’s agent build their version. Karpathy’s idea file is an interesting format for passing around software that people are meant to customize.
Nick Spisak shares raw setup notes for a personal knowledge system combining summarization tools, Obsidian, QMD, and a custom CLI. His suggested inputs include YouTube material, agent logs, and a requested X archive.
Pocket note
Videos, agent logs and an X archive, all searchable from one little command. Start with one topic and keep a link back to every original. The satisfying part is asking a question that used to require opening three different apps.
César Álvarez breaks down a Bible chat app's onboarding, from reviews and preference questions to a trial paywall. His post includes a walkthrough of the sequence.
Pocket note
Notice how quickly the onboarding asks you to participate. Map each screen to a job: understand the offer, express a preference, see something relevant, decide. Then find the first moment someone gets value from answering.
@igormomentum groups accounts across AI, design engineering, developer media and databases. The list is useful as a discovery starting point, while the supplied role labels should be checked before being treated as current.
Pocket note
A good feed needs people making things, people explaining them, and people with irritatingly good taste. Pick a few from Igor’s list around whatever you’re building next. Follow the actual release, repository or design breakdown when something catches your eye.
@cailynyongyong publishes a chaptered conversation about posting and product demos on X with @minmax0501. The outline includes audience, brand message, opening seconds, scripting and keeping a video focused on one feature.
Pocket note
One feature per demo. Show the result early, then the few actions that make it happen. Caitlyn’s chapter list has a whole section on the opening seconds; a useful place to start when a product video takes too long to get anywhere.
Rabin’s post connects several company agent projects to a broader software-factory idea. It emphasizes orchestration and distribution; the bookmark itself is a perspective and set of leads rather than a technical comparison of those systems.
Pocket note
The software-factory idea gets interesting between the coding steps: who supplies the context, reviews the change and gets it into someone’s hands? Follow one small request through that whole path. The awkward handoff is often the thing worth building around.
@LottoLabs lists a local-model setup pairing two home GPUs with Hermes Agent, Tailscale and Termius. It is a compact stack reference; the post does not provide installation steps or a measured performance report.
Pocket note
The GPUs stay home; the terminal comes with you. This compact stack sketch joins a local model and agent to a remote connection and phone client. A pocket-sized doorway into a much less pocket-sized machine.
@KyeGomezB presents OpenMythos as a theoretical PyTorch reconstruction using repeated transformer blocks and sparse expert routing. The author explicitly frames the efficiency and reasoning properties as a hypothesis being explored.
Pocket note
An architecture hypothesis you can poke at: reuse a transformer block, route through selected experts, and spend more iterations on reasoning. OpenMythos makes the proposal tangible in code. The interesting next step is seeing where that trade holds up in an experiment.
Rabin’s saved post collects developments in local inference, including speculative decoding, prefill and open research stacks. Its performance figures are a snapshot of reported results rather than independently reproduced benchmarks here.
Pocket note
Local inference has several moving parts: getting the prompt in, getting the first token out, and keeping the answer flowing. Use this roundup to choose one experiment, then time it on a task you actually repeat.
@EXM7777 suggests recording the situation that triggered a skill and the outcome or correction after each use. The next run reads a short recent history rather than beginning without that feedback.
Pocket note
After a recurring skill runs, record the situation and one checked lesson: what failed, what fixed it. Read the relevant entries before the next run. Keep the log small enough that the same mistake can’t hide under pages of notes.
@an_engineer_log introduces Minions as a supervision interface for Hermes Agent. The stated problem is visibility across parallel tasks, blocked work and scheduled jobs that can fail without being noticed.
Pocket note
Twenty agents means twenty opportunities for a job to quietly get stuck. The useful dashboard answers three questions quickly: what finished, what stopped, and what needs me? Minions is a bookmark for that increasingly familiar coordination problem.
@DilumSanjaya describes building an interactive app around generated 3D biological structures. The post separates the visual-design tool from the coding tool and links further demos.
Pocket note
Give a 3D object one question to answer: how do these parts connect? Add rotation, two useful labels and a reset view. Dilum’s science-app demo is a nice starting point for turning something you look at into something you can explore.
@MilksandMatcha describes moving from a computing and quantitative background into AI work. Their suggested starting points pair an introductory LLM explanation with familiar development tools and hands-on everyday tasks.
Pocket note
Start with a task you already know how to judge. Let an assistant try it, compare the result, and investigate the bits you don’t understand. Familiar work gives you somewhere solid to stand while learning unfamiliar tools.
@josefchen announces a multilingual food-model paper and gives compactness and dataset figures. The saved announcement does not include the paper’s evaluation method, so the scale and capability claims remain attributed.
Pocket note
A tiny model devoted to food is a pleasingly specific research direction. The question to take into the paper: what relationships between recipes and ingredients survive in that compact representation, especially across languages? That’s more interesting than the download size alone.
@keennay documents a hybrid CPU/GPU inference experiment using KTransformers, including configuration flags, test conditions and memory headroom. Their reported timing and throughput figures belong to that specific setup.
Pocket note
Keennay shows the knobs: expert placement, RAM use, GPU headroom, caching and concurrency. Keep those settings beside the benchmark. If you borrow the setup, change one at a time so you can tell which trade actually helped your workload.
@bridgemindai reports a coding session whose charges were split between the chosen model and a fallback. Their explanation of the routing behavior is a first-person account, not an independently verified diagnosis.
Pocket note
A surprisingly expensive session deserves a look at the receipt. Split out the chosen model, fallback calls and retries, then compare them with the finished work. The model name you clicked may explain only part of what happened.
@Tech2Wild reports running a large GLM model across four DGX Spark machines and links a reproduction recipe. The post distinguishes single-stream from concurrent throughput; neither result has been reproduced here.
Pocket note
Four small machines, one very large model. The interesting distinction in this build is single-user speed versus throughput across several requests. A server that chews through a queue can still feel slow when you’re waiting for its first sentence.
@ClaudeDevs describes a two-model pattern in which an executor asks a separate advisor for guidance. The post frames the split as a way to concentrate higher-cost reasoning on selected decisions.
Pocket note
Let the executor do the routine work and send one difficult decision to the advisor. Give that advisor the relevant context and a specific question. Then check whether the advice actually changed the result enough to justify the extra call.
@h100envy summarizes an Unsloth-related interview spanning kernels, quantization and training methods. The post is a topic map for the linked conversation; its speed and hardware claims remain source claims.
Pocket note
A useful rabbit hole if fine-tuning still feels like one mysterious operation. This interview map separates model choice, kernels, quantization and training objectives. Pick the bit you actually need to understand, then follow it into a working example.
@EXM7777 proposes a compact business vault covering the offer, customer, voice, playbooks and decisions. Each worker receives the material relevant to its task, while recurring corrections go into a shared decision record.
Pocket note
Give the writer the voice guide, the researcher the relevant sources, and both the decisions they must respect. Keep the whole vault available without stuffing it into every task. Different jobs need different slices of the same memory.
@elder_plinius links a Black Hat presentation about a QR-code prompt-injection demonstration involving a Unitree robot. The saved post identifies the physical-action risk but does not supply the full experimental method.
Pocket note
The unsettling question: when a robot reads something in the room, who gets to give it instructions? This QR-code demo takes prompt injection out of a chat window and puts it somewhere with legs.
@mightyking shares a detailed cooking-video prompt with a ten-shot sequence, camera instructions and explicit continuity constraints. The useful material is the production brief; the claimed output quality has not been independently evaluated here.
Pocket note
Food continuity is the sneaky hard part: chopped ingredients stay chopped, cooked chicken stays cooked, and the plate doesn’t refill itself. Before generating a cooking sequence, jot down the food’s state at every cut. Give the meal a memory.
Karpathy shares an experiment turning a story opening into a procedural Three.js scene, and reflects on where agent-made worlds still fall apart.
Pocket note
A paragraph of fiction becomes a slightly broken place you can wander around. The delightful possibility here is extremely specific, disposable worlds. Karpathy’s catch: the agent can build the scene more easily than it can judge the experience of moving through it.
TechHalla shares a Seedance diner scene and its shot-by-shot prompt: a collision, suspended coffee, and one very unbothered escape.
Pocket note
Write the time-freeze gag as four beats: spill, freeze, escape, crash. Decide exactly who can still move in each beat. That’s the trick in TechHalla’s diner prompt; the neon and film grain are the garnish.
Beech’s early-2000s camcorder experiment uses shaky framing, blown highlights and late reactions to build a convincing period look.
Pocket note
The camcorder look lives in the person supposedly holding it: a zoom that overshoots, a reaction caught late, an exposure that struggles with the sun. Give each shot one believable operator mistake. Instant 2003 pool-party energy.
Machina describes an Obsidian setup that gives a coding agent working context: offers, customer fit, playbooks, objections and previous decisions.
Pocket note
Put the offer, ideal customer, recurring objections and past decisions in a small folder. Then give the agent an actual distribution task and ask which notes support its answer. A much better starting brief than asking it to figure out your entire business.
Charly Wargnier breaks down where TypeSafe’s Jev fits into an agent workflow: choosing, scoring, routing and escalating.
Pocket note
Pick one fork in an agent workflow and make the answers explicit: continue, use another tool, or ask a human. Wargnier’s Jev breakdown is interesting at that scale. Measure whether the whole task improves when that decision changes.