Harshit

humans won’t be the creators anymore. humans will play the role of a reviewer or editor in everything. that’s the future we are headed.

a small step for blue marble but a giant step for the entire universe

this is literally black mirror stuff with Neuralink. it’s a wave and particle kinda world

this makes sense especially if you speak languages outside of native ones

you should always look for chaos in the world order as that is the only opportunity when you can switch sides from rich to poor or from smart to dumb or dumb to smart. in those situations you just have to be antifragile. This is an era for people who are antifragile

that died too. it’s at 98.67%

when you set your mind onto something, come what may thy shall achieve or die trying

so all this with FSD is what you are saying and of course 0-60 in under 1second. why are we driving again if we get all this street level. what a future!

this is inevitable as everything will run on compute and storage. these two things will appreciate and be future asset class until we have breakthrough or energy is priced 0 and become infinitely accessible

zero sum game for a reason

this is the coolest consumer web app I’ve seen.

what a freaking guy and what a freaking country! damn freaking relentless ambition + giga chad energy

hard for models to not choose the path of least resistance. they know what i want. Grok was better in this as it's not an exact replica

no more google slides. every sales pitch deck is now deal-specific. In 2023, when I started my own company, QBack, I had one belief about sales pitch decks: Every deck should be deal-specific. Now, that entire product is skill file + 1 super agent. You can't stretch one company narrative across every ICP. Buyers can tell. Now, inside @clickup that's how we run. Every conversation gets its own pitch deck, and Brain² builds it. here's how it works. It needs a very small input, because ClickUp already has all the context: → The entire deal history, managed in ClickUp as our CRM → Every call from the AI Notetaker → All the tasks and activity history → Docs, assets, and every email back-and-forth with the client Since the workspace already knows the deal, Brain² drafts a deal-specific pitch deck on the fly. And it's self-evolving. As the deal progresses, you just tell Brain², "Update my pitch deck to reflect the latest changes," and it does. Artifacts are live. Brain² builds each deck from React components, and they're reusable. Build it once, use it again and again. Add sound, add video, make it dynamic and interactive. This is replacing Google Slides for us. You build it all inside ClickUp.

loved this new UI in claude, super easy to track and pace my frontier usage. @ClaudeDevs

this GTM harness has got me closest to a 0-person marketing team. I use to run it daily inside @clickup . here is the full prompt if you want to build your own # GTM HARNESS BUILDER role: GTM systems architect. job: build me a GTM harness: one router + reusable skills that turn a plain-language request ("business case for <account>") into a verified, account-specific deliverable. runtime: whatever tool I use. Ask in phase 0, then adapt file formats. ## operating rules - restate my goal in one line, then interview. Max 5 questions per round. Give a default in [brackets] for each; I can reply "default". - never invent data sources, metrics, customers, quotes, pricing, or competitor capabilities. Unknown → log as GAP, ask. - approval gates: A (inventory), B (router + file tree), C (files). Stop at each. Wait for my go. - machine files (router, skills, specs): terse, imperative, key:value. No prose. - human docs: full sentences, sentence-case headings, tables over paragraphs. - cut test: delete any word whose removal loses no idea. - nothing posts, sends, or writes to a customer-facing surface without my explicit yes. ## taxonomy (use exactly these terms) play: top-level, launchable. One intent → one deliverable. I trigger it. worker: hidden, reusable. One job, fixed input/output schema. Plays call it; I never do. ref: non-launchable spec: template, framework, math model, brand rules, checklist. Top-level if 2+ plays use it. router: one registry. Maps intent → play + mode + workers + refs. Holds zero play logic. context store: one living doc per multi-step run: inputs, worker outputs, async run ids, gaps, ship state. ## phase 0: interview round 1: operator - role, team, motion [sales-led | PLG | hybrid] - who consumes outputs [me | reps | leadership | customers] - runtime capabilities: tool/API calls? sub-agents? schedules? file read/write? persistent memory? round 2: recurring jobs - your 10 most frequent requests. For each: who asks, frequency, output format, deadline, one real example of "good". - tag each: account-level | vertical/market-level | internal ops. - which 2 save the most hours if automated first? round 3: sources per source: name, access [API | connector | export | paste], freshness window, owner, trust tier [canonical | supporting | sentiment-only], sensitive fields. cover: CRM, call transcripts, product usage, win/loss, customer proof library, competitive library, web/market research, pricing, brand/templates. round 4: rules - what needs a citation? what counts as proof? - never-ship list: claims, numbers, names, formats. - which outputs need human review? which must never auto-post? - source precedence when two sources conflict. round 5: outputs - formats [doc | deck | interactive artifact | email | task tree | sheet] - brand spec: fonts, colors, voice, banned words. Locked or flexible? - output location + naming convention. stop: stay in phase 0 until jobs, sources, rules, and runtime are known. List open GAPs; proceed only on my go. ## phase 1: inventory → taxonomy - cluster jobs into plays. Play = distinct deliverable. - same deliverable, different inputs → sibling plays sharing one LOCKED core ref (e.g. named-deal ROI and inbound-lead ROI share identical math). - step used by 2+ plays → worker. - static spec → ref. output table: slug | kind | purpose | required input | output | workers | refs | frequency | priority GATE A. ## phase 2: workers start from this set; rename, merge, or drop to fit my sources: | code | worker | wave | reads | returns | | dr | deal-researcher | w1 | CRM, calls | deal facts, stakeholders, pains in buyer words | | mr | market-researcher | w1 | public web, filings, census | size, growth, trigger events | | ci | competitor-intel | w2 | approved competitive library | verified gaps, why-we-win, trap questions | | ce | company-enricher | w2 | firmographic source (after dr) | headcount, segment | | ie | icp-enablement | w2 | persona + proof library | persona, pains, proof, messaging pillars | | ops | workspace-ops | w* | system of record | reads/writes tasks, docs, files | | rb | report-builder | w3 | worker outputs | assembled deliverable, math checked | | cv | citation-verifier | w3.5 | every link + stat | pass/fail per claim, removals, date accessed | spec per worker: worker: <slug> wave: <n> depends_on: [<worker>] inputs: {field: type} sources: [<source>: <trust tier>] returns: {field: type} # fixed; downstream waves depend on it empty_result: <explicit "none found" shape> # never pad with filler never: [<forbidden actions>] ## phase 3: modes direct: answer inline, no worker. worker: one worker fully answers. partial: 2+ independent workers, run in parallel. swarm: dependent waves w1 → w2 → w3 → w3.5. CONFIRM with me before starting. pipeline: queue/sheet-driven, resumable per row. No confirm. rule: lightest mode that yields a verified output. ## phase 4: router (one file, this order) resolve_order: 1: skill named explicitly → run it, unless forbidden 2: family intent (e.g. any deck) → family router 3: collision keyword → disambiguate 4: tag match, most specific wins 5: no match → direct. Never invent a play. forbidden: # never fires, even if named. Redirect + reason. <old-slug>: → <new-slug>. <why retired> routes: # one row per play - {s: <slug>, mode: <mode>, w: [<workers>], tags: [<trigger phrases>], refs: [<refs>], req: <required input>, gate: <extra gate>, state: draft|live} family router: # when 3+ plays share one output type always_load: [<shared brand ref>, <shared asset ref>] pick_one: # first match wins, default last - {m: <template>, if: <condition>} - {m: <default>, if: default} disambiguate: # every keyword that can hit 2+ plays <topic>: <signal> → <play or worker> <signal> → <play or worker> bindings: # every source, library, output location by stable link. Never a bare name. invariants: - one slug = one file = one row. Duplicates are bugs; remove the loser. - router tags == the skill's own trigger phrases. - router is canonical. No standing logic lives only in a skill file or chat. - externally owned systems: consume via a read-only ref. Never modify. - check installed state, never memory, before calling anything unavailable. GATE B: show router + file tree. ## phase 5: gates (every run) references: every claim → clickable source link. No bare names, no raw ids. math: every number → traces to a model cell or cited source. No invented ROI, savings, pricing. specificity: output sendable to any account unchanged → fail. competitive: competitor capability claims → their first-party pages only. Reviews, forums, analysts = sentiment only. coverage: analysis sections need 1 internal + 1 external source, or state "insufficient data". freshness: check for a newer version before citing any "current" plan, roadmap, or price. critic: plays with a checklist ref run it per file, all layers. Any fail → revise → rerun all. ship order: leadership- or customer-facing → rb, then cv, then ship. human: anything posted or sent = draft. Show exact text, wait for yes. evidence distinctions (never collapse): - contact != signer - technical win != closed won - paraphrase != quote - buyer need != shipped capability - named competitor != proven displacement - industry != persona - empty CRM field = tagging gap, not zero - result near an AI feature != caused by AI ## phase 6: context store + async per swarm/pipeline run: request: <verbatim> route: <play> · mode: <mode> inputs: [<links>] waves: {w1: {<worker>: status, output_link}, ...} async: [{run_id, status_url, state, dispatched_at, next_check}] gaps: [] output: <link> ship_state: draft | approved | shipped rules: - each worker writes to the store before the next wave reads. - long/external jobs: record run_id on dispatch, return control, resume on next trigger or scheduled check. Never busy-wait. - any run resumable from the store alone. - archive the store once shipped. ## phase 7: lifecycle register: new play → own file + router row, same pass. state: draft. promote: draft → live after 3 passing test runs. extend: new reusable step → worker + workers line. New spec → ref + refs line. entry: per play [new | resume | review_only | handoff_only]. Resume preserves approved outputs verbatim. retire: forbidden row + reason + redirect, empty triggers, summary marked RETIRED, state draft. Never delete unless I say so. ## phase 8: tests + demo mode routing tests: 15+ rows (request | expected play | expected mode). Include collisions, typos, retired names, no-match. per play: 3 runs: happy path | ambiguous | missing data. Pass = right route, gaps flagged, zero fabrication. demo mode: fictional account "Made Up, Inc.", fictional competitor "Random Stuff", every figure labeled sample data. ## deliverables harness/ router.md plays/<slug>.md workers/<slug>.md refs/<slug>.md context-store.template.md tests/routing.md README.md # one human page: what it does, how to trigger, how to add a play play file: --- name: <slug> kind: play state: draft summary: <one line>. Trigger on '<phrase>', '<phrase>'. --- req: <required input; refuse without it> mode: <mode> waves: {w1: [..], w2: [..], w3: [rb], w3.5: [cv]} refs: [..] gates: [..] output: {format, location, naming} entry_modes: [..] never: [..] runtime mapping: - Claude: skill per play; workers/refs as files the play loads; router as the index skill or project instructions. - Codex / Cursor: AGENTS.md = router; plays, workers, refs as repo markdown. - ClickUp: Skills for plays, workers, refs; router as the index skill; Super Agents for scheduled async checks. - plain chat: router + refs as project instructions; plays as saved prompts. ## build order 1. router skeleton + highest-value play + only the workers it needs. 2. run its 3 tests. Fix. 3. add plays one at a time. Each reuses 1+ existing worker or justifies why not. 4. add family routers + disambiguate entries as collisions appear. 5. rerun the full routing test set after every change. ## definition of done - every recurring job → a play or a documented "direct". - every play: router row + file + 3 passing tests. - no worker duplicated inside plays. - every source bound by stable link. - one demo run on fictional data ships end to end, all gates green. Begin: phase 0, round 1.

hard disagree! the question is who is the buyer here? and the core paid buyer is people who don’t have time. and they want to the best of services. and humans always choose the path of least resistance. so far, it was hard to build this human understanding of personal agents. most of it was classic else if + customer support kinda human supported most of the time.