Lvtd Skills

Plan small, playable Rust game implementation slices from a short design brief, MVP, stretch goals, and acceptance checks. Use when starting a Rust game, scoping a prototype, converting a game idea into work items, or preventing an AI coding agent from overbuilding.

Design and review Rust ECS gameplay code using Legion-style entities, components, resources, systems, schedules, queries, command buffers, and spawners. Use when building ECS-driven Rust game features, migrating game state into ECS, or debugging system ordering and component composition.

Design and review Rust ownership, borrowing, lifetimes, and interior mutability so data flow matches the domain model. Use when writing, refactoring, or reviewing Rust code that hits move, borrow checker, aliasing, Clone, Copy, Rc, Arc, RefCell, or lifetime problems.

Build and review turn-based Rust game flow using turn-state enums, phase-specific schedules, intent messages, movement resolution, combat resolution, wait actions, and win/loss states. Use when implementing roguelike turns, tactical action order, ECS message entities, or decoupled input and action systems.

Find product-led and blue-ocean SEO opportunities from customer demand, query behavior, competitive gaps, search result features, communities, and proprietary product strengths. Use when researching SEO opportunities, organic growth ideas, competitive SEO gaps, programmatic SEO concepts, or when keyword tools show little volume.

Design email marketing traction tests from Traction for acquisition, engagement, retention, revenue, and referrals. Use when planning email courses, newsletter sponsorships, lifecycle sequences, retention emails, or email-driven growth experiments.

Plan and synthesize pre-draft reader conversations for useful nonfiction books, including listening interviews, teaching calls, reader-language capture, promise validation, scope refinement, and TOC testing. Use when validating a practical book idea, finding target readers, preparing interview prompts, testing a table of contents, or turning reader conversations into book decisions.

Model, migrate, refresh, and verify PostgreSQL materialized views in Django for expensive report or dashboard queries that can tolerate stale data. Use when ORM/index/query rewrites are not enough, the result is read often, freshness can be bounded, and a Django app needs unmanaged models, RunSQL migrations, refresh commands, or concurrent refresh.

Read and compare Django/PostgreSQL query execution plans using QuerySet.explain(), EXPLAIN, EXPLAIN ANALYZE, scan types, joins, estimates, actual timing, buffers, and row counts. Use when one SQL query dominates Django latency or when an index, ORM rewrite, pagination change, or materialized view needs proof from a query plan.

Apply 80/20 power-curve thinking to sales, marketing, customers, offers, traffic, time, and operations. Use when finding leverage, diagnosing uneven results, prioritizing high-upside segments, or replacing average-based reasoning with Pareto and power-law analysis.

Plan, draft, review, and operate audience-relevant link outreach campaigns with personalization, subject lines, response handling, tracking, and bulk-send guardrails. Use when writing link outreach emails, pitching resource pages, handling outreach replies, planning blogger or journalist outreach, reviewing subject lines, or managing link acquisition workflows.

Research link-building opportunities by mapping assets to opportunity types, building query libraries, analyzing competitor backlinks, finding scrapeable lists, and expanding prospecting seeds. Use when finding link prospects, creating link prospecting queries, mapping guest post/resource/directory opportunities, or producing a prospect research map before qualification or outreach.

Use when designing, implementing, testing, or debugging Rust service workflows that must be safe under retries, duplicate requests, crashes, concurrent submissions, background workers, queues, email/payment/notification side effects, idempotency keys, transaction isolation, or save-and-replay API behavior.

Design and review Rust iterator pipelines and collection code for clear ownership, allocation, ordering, and error behavior. Use when writing, refactoring, or reviewing iterators, HashMap Entry usage, collect, FromIterator, Extend, custom iterators, or allocation-heavy loops.

Design and review Rust roguelike procedural maps, map-builder traits, generator harnesses, field-of-view, spatial memory, Dijkstra/pathfinding, and simple monster AI. Use when adding dungeon generation, FOV, map memory, chasing behavior, or visibility-constrained AI to a Rust game.

Design hands-on technical nonfiction chapters as runnable labs, worked examples, exercises, checkpoints, troubleshooting paths, and reader outcomes. Use when turning technical book sections, tutorials, self-hosting chapters, DevOps guides, programming lessons, or infrastructure explanations into practical labs that readers can complete and verify.

Research and shortlist startup traction channels before running Bullseye tests. Use when comparing acquisition channels, studying how similar companies grew, finding underused distribution strategies, or preparing the outer ring for a Traction-style growth process.

Plan existing-platform, trade show, offline event, speaking, and community-building traction experiments from Traction. Use when testing platform distribution, conferences, meetups, talks, forums, local events, or community-led startup growth.

Plan paid acquisition tests from Traction across SEM, social/display ads, and offline ads. Use when designing ad experiments, keyword tests, audience tests, paid channel budgets, or deciding whether a paid channel can acquire the right customers profitably.

Move Django performance-sensitive Python loops into database-side computation with annotations, aggregates, filtered aggregates, F expressions, functions, Subquery, OuterRef, Exists, Window expressions, db_default, and GeneratedField. Use when Django code counts, sums, filters, flags, ranks, or derives values in Python after fetching rows.

Plan and implement conversions between game meshes, SDFs, voxels, images, contours, and smooth curves while preserving enough gameplay and rendering data. Use when repairing meshes, extracting meshes from fields, voxelizing geometry, contouring, denoising voxel data, generating LODs, or moving geometry between representations.

Review a game for player impact, ethics, transformation, inclusion, monetization pressure, community risk, dark patterns, and hidden design agendas. Use before shipping manipulative loops, social systems, ads, monetization, retention mechanics, UGC, or player-generated communities.

Design or evaluate game story, world, characters, spaces, presence, aesthetics, and indirect control. Use when adding narrative, quests, levels, environments, character arcs, worldbuilding, environmental storytelling, or emotional context to gameplay.

Model target players, motivations, emotions, pleasures, needs, flow, novelty, judgment, and interest curves. Use when defining who a game is for, shaping retention, diagnosing boredom or confusion, designing progression, or aligning gameplay with a desired emotional arc.

Use when adding, changing, testing, or reviewing Postgres persistence in Rust services that use sqlx, especially when designing migrations, query! or query_as! calls, PgPool injection, transactions, compile-time checked SQL, SQLx offline mode, repository boundaries, or database-backed integration tests.

Plan and check the final production tasks for self-publishing nonfiction books, including copyediting, final review readers, proofreading, layout, cover files, print-on-demand, ISBNs, and launch-readiness sequencing. Use when preparing a manuscript for publication after beta reading or when auditing a self-publishing checklist.

Map SEO personas, search intent, funnel stage, expected content format, CTA, device context, and localization needs into actionable organic search plans. Use when planning keyword research, SEO content briefs, funnel mapping, search intent analysis, persona-driven content, or when traffic is not converting.

Prioritize SEO initiatives as product roadmap work with impact, effort, confidence, resourcing, executive pitch, cross-functional ownership, quarterly planning, and business KPI alignment. Use when building SEO roadmaps, scoring SEO work, requesting engineering/design/content resources, annual planning, executive buy-in, or turning SEO recommendations into product-ready asks.

Plan business development, sales, and affiliate traction experiments from Traction. Use when testing partnerships, direct sales conversations, outbound lists, affiliate programs, channel partners, or revenue-oriented startup acquisition channels.

Plan viral marketing and engineering-as-marketing traction experiments from Traction. Use when designing referral loops, viral coefficients, engineered acquisition tools, calculators, microsites, widgets, or product-led assets that acquire customers; use make-product-viral instead for landing-page audits, shareability reviews, pricing-page polish, or social-preview optimization.

Optimize Django and pytest-django test execution in CI with cache configuration, slow-test splitting, database reuse strategy, parallel workers, pytest-xdist, CircleCI/GitHub Actions/Jenkins/Travis patterns, and full-coverage safeguards. Use when CI test jobs are slow, flaky under parallelism, missing slow-test coverage, or need a local-vs-CI test command design.

Safely parallelize Django and pytest-django test suites with Django --parallel, pytest-xdist, test isolation checks, randomized order detection, shared-resource sharding, locks, and load balancing. Use when enabling parallel tests, diagnosing failures under parallel execution, handling flaky Django tests, or making caches, files, queues, and external resources safe across workers.

Create 80/20-style unique selling propositions, guarantees, and result-based offers. Use when positioning an offer, strengthening a value proposition, raising prices, creating a guarantee, or making a sales promise more specific and credible.

Model game shapes, volumes, influence, procedural objects, and effects with signed distance functions, implicit functions, scalar fields, vector fields, and deformation fields. Use when building SDF primitives, field composition, raymarching inputs, organic procedural shapes, offsets, Booleans, deformation, or field-driven gameplay.

Apply vector math primitives for game rendering, collision, orientation, lighting, steering, and geometry predicates. Use when working with dot products, cross products, triple products, normals, projections, signed areas, signed volumes, facing checks, or vector normalization.

Qualify, score, filter, and prioritize link-building prospects by relevance, trust, editorial quality, authority, outreach fit, spam risk, and asset readiness. Use when reviewing raw URL lists, deciding which sites are worth outreach, auditing link target quality, segmenting prospects, or rejecting risky link opportunities.

Design and review thread-based Rust concurrency with explicit ownership, sharing, and synchronization choices. Use when writing, refactoring, or reviewing threads, scoped threads, channels, Arc, Mutex, RwLock, Condvar, atomics, OnceLock, LazyLock, Send, Sync, deadlocks, or shared state.

Find and frame customer conversations through warm intros, communities, casual chats, events, advisors, landing-page replies, and meeting requests. Use when a team needs people to interview, cold outreach is failing, a meeting ask sounds needy or pitchy, or customer discovery needs a credible reason to talk.

Design and review Bevy fixed-step 2D physics loops with velocity components, deterministic movement, collision prediction, interpolation, impulses, and tweened presentation. Use when movement depends on frame rate, collision misses appear at high speed, physics and animation are tangled, or Bevy gameplay needs stable simulation steps.

Optimize Django ORM query loading by fixing N+1 queries, duplicate related-object queries, over-fetching, serializer/template query loops, and inappropriate select_related, prefetch_related, only, or defer usage. Use when a Django page, API, admin view, template, serializer, or queryset issues too many queries or loads more model data than needed.

Improve Django and Django REST Framework pagination for large querysets using bounded page sizes, stable ordering, indexed ordering, offset limits, keyset pagination, DRF CursorPagination, and count-query tradeoffs. Use when list pages, admin views, APIs, exports, or infinite scroll become slow, inconsistent, or memory-heavy as result sets grow.

Design smooth game motion with splines, Bezier curves, interpolation, derivative continuity, path parameterization, and speed control. Use when implementing camera rails, waypoint paths, vehicle routes, projectile trails, animation curves, roads, rivers, or any motion/path system that must feel smooth.

Move Rust game monsters, items, loot, effects, spawn weights, level gates, and balance numbers into validated data files using Serde-friendly schemas. Use when replacing hard-coded spawn functions, adding RON or JSON content templates, or making game content editable without recompiling.

Design and review Rust tile maps, map indexing, collision checks, map builders, camera-relative rendering, layered drawing, and tile themes. Use when building 2D grid worlds, roguelike maps, tile cameras, or bracket-lib style rendering systems.

Write and review Rust library documentation with rustdoc module docs, public API examples, doctests, examples directories, missing-docs gates, docs.rs readiness, and user-first crate narratives. Use when documenting a Rust crate, improving docs before publishing, or turning examples into tested rustdoc.

Diagnose the single B2B sales constraint currently limiting pipeline or revenue and route to the right repair workflow. Use when sales feels stuck, pipeline is weak, leads ghost, outbound is not working, conversion is unclear, or the team is debating whether to fix reach, messaging, follow-up timing, or trust.

Evaluate whether customer, sales, investor, partner, or product meetings produced real commitment and advancement instead of polite interest. Use when interpreting meeting outcomes, stalled leads, trial requests, letters of intent, preorders, warm intros, case-study offers, unclear next steps, or compliments after a pitch.

Diagnose and prioritize sales funnel improvements by economics, conversion, split testing, and high-value customer potential. Use when optimizing funnels, deciding what to test, improving CAC or profit, evaluating upsells, or choosing the few metrics that matter now.

Find hyper-responsive buyers and disqualify weak markets using 80/20 Sales and Marketing. Use when choosing a target segment, validating demand, screening prospects, finding urgent buyer problems, or deciding whether a market is worth sales and marketing effort.

Prioritize traffic, media, lists, and audience sources with an 80/20 lens. Use when choosing acquisition media, deciding which traffic source to master, evaluating rented or owned lists, sequencing channel expansion, or shifting budget toward higher-leverage sources.

Design and review Bevy 2D collision broadphase systems with AABB bounds, spatial indexes, typed collision events, and benchmark-driven test beds. Use when replacing O(n^2) collision checks, adding spatial partitioning, diagnosing Bevy collision performance, or separating broadphase, narrowphase, and response systems in Rust games.

Plan, prospect, evaluate, fulfill, and measure local sponsorship campaigns that build local visibility, relationships, and links through events, nonprofits, community organizations, and local publishers. Use when finding local sponsorship link opportunities, evaluating sponsorship packages, building local links through nonprofits or events, measuring sponsorship ROI, or using local relationships for SEO.

Analyze nonfiction manuscripts for reader engagement signals, including heading-level word counts, slow starts, long slogs, weak takeaway titles, value pacing, beta-reader comment dropoff, and abandonment risks. Use when auditing a book, guide, manual, course-like draft, or technical manuscript for value density, reader experience, or beta-feedback engagement patterns.

Prepare Rust crates for publishing with Cargo metadata, versioning, README and license checks, package dry-runs, feature verification, docs.rs readiness, examples, changelog notes, and secret-safe release gates. Use before cargo publish, crate release PRs, or sharing a reusable Rust library.

Plan and audit customer discovery conversations that produce concrete evidence instead of compliments, opinions, hypotheticals, or feature-request noise. Use when planning customer interviews, rewriting interview scripts, validating startup ideas before building, avoiding biased questions, or applying Mom Test-style customer learning.

Process large Django querysets and write-heavy jobs with memory-safe reads, values/values_list, iterator chunking, set-based update/delete, bulk_create, bulk_update, F expressions, Func expressions, and batch sizing. Use when a Django command, task, migration, report, or loop reads or writes many rows and is slow, memory-heavy, or query-heavy.

Build high-leverage sales messages that attract qualified buyers and repel poor-fit prospects. Use when writing or diagnosing headlines, landing pages, outreach, ads, sales letters, lead magnets, or B2B messages where urgency, qualification, and conversion matter.

Segment customers and lists by 80/20 value, responsiveness, recency, frequency, and money. Use when identifying best customers, prioritizing follow-up, finding high-value buyers, pruning low-value accounts, or deciding what customer data to measure.

Apply 80/20 leverage to time, talent, assistants, outsourcing, hiring, salespeople, and low-value work. Use when deciding what to delegate, outsource, stop doing, hire for, trial, or remove so high-value people spend more time on their strongest work.

Optimize Rust libraries with criterion benchmarks, feature-flag matrices, cargo bench workflows, dependency gating, regression baselines, and evidence-driven API performance tradeoffs. Use when adding or reviewing Rust library benchmarks, cargo features, optional dependencies, or performance claims before publishing.