Quick-reference guides. Printer-friendly. Mobile-friendly. No fluff.
New to AI-assisted development? Learn what vibe coding is, the core terminology (LLM, agentic, BYOK, MCP, vibe check), the four types of vibe coding, how to choose your stack, and the essential skills every vibe coder needs.
Ubuntu server administration — systemd service units with enable/start/stop and journalctl log viewing, file permissions (chmod, chown, umask), cron job scheduling with logging, SSH hardening and key-based auth, UFW firewall configuration, networking with ip and ss commands, disk usage with df/du, process monitoring with htop, package management with apt, and automated security updates.
Everything a beginner needs to know about Large Language Models — how they work (tokens, transformers, inference), core terminology, Q models and quantization (GGUF, Q4_K_M), major models compared, local vs cloud, prompting basics, and common misconceptions debunked.
ML fundamentals — supervised, unsupervised, and reinforcement learning explained. Algorithm selection guide, scikit-learn pipeline with code examples, evaluation metrics (precision, recall, F1, ROC/AUC), overfitting prevention, common pitfalls like data leakage and imbalanced data, the full Python ML stack, and your first project with the Iris dataset.
Daily Git workflow covering init, clone, add, commit, push and pull with branch management. GitHub-specific features like PRs with review requests, issue templates and labels, release tagging via GitHub Releases, GitHub Actions CI/CD workflows, merge conflict resolution strategies, and SSH key setup for authentication.
Cypress and Playwright side by side covering test runner setup, locator strategies (CSS, XPath, text, role selectors), assertions and matchers, wait strategies (auto-waiting vs explicit timeouts), network mocking and interception, visual regression testing, test organisation with fixtures and hooks, CI integration with GitHub Actions, cross-browser testing, and API testing workflows.
Jest and Vitest side by side covering test structure (describe/it/expect), matchers (toBe, toEqual, toContain, toThrow, and custom matchers), mocking with jest.mock and vi.mock, spies, timers, snapshot testing, coverage reporting with thresholds, configuration with jest.config and vitest.config, TypeScript integration, and performance comparisons with watch mode and selective test runs.
Everything you need to run a Discord server — role hierarchy and permissions, channel types and categories, server settings including verification levels and 2FA, built-in auto-mod rules, moderation workflows (timeout/kick/ban), audit log usage, community features like onboarding and welcome screen, bots and webhooks integration, server boosting, and Nitro explained (Basic vs Full tier perks).
Everything Docker — installation on Linux, Windows (WSL 2), and macOS, Docker Desktop GUI walkthrough (dashboard, images, volumes, settings) vs CLI-only engine comparison, complete CLI quick reference with Windows PowerShell commands, multi-stage Dockerfile with all 13 instructions, layer caching best practices, Docker Compose with healthchecks, volumes (named, bind, tmpfs), networking with port mapping and custom networks, container lifecycle and resource limits, pushing/pulling to registries with multi-architecture builds, and a troubleshooting table.
Editor shortcuts for navigation, multi-cursor editing, and command palette workflows. Integrated terminal setup and launch configs for debugging Node.js, Python, and browser apps. Cline BYOK AI agent configuration, MCP server setup and troubleshooting, settings sync, recommended extensions for web and game development, and workspace-specific configuration profiles.
Bash and Zsh essentials including filesystem navigation with pushd/popd, file manipulation with find and xargs, grep and sed for text processing, process management with jobs/kill/nohup, I/O redirection and piping patterns, permission management with chmod/chown, shell aliases and functions, scripting basics with loops and conditionals, and history search tricks.
AWS CLI (S3, Lambda, ECS/ECR, CloudWatch), Vercel CLI (deploy, env vars, logs, rollbacks), Netlify CLI (deploy, env, functions, dev server), and Cloudflare Wrangler (Workers, KV, D1 SQLite database, R2 object storage, Queues, Pages) with CI/CD workflow snippets for GitHub Actions.
Side-by-side comparison of npm, yarn, and pnpm covering install, remove, update, and run scripts. Package resolution and lockfile differences, npx vs dlx for one-off execution, workspace support for monorepos, publishing packages with access control, semantic versioning ranges and caret/tilde/tilde operators, caching strategies, and .npmrc configuration for registries and authentication.
All built-in hooks with signatures and common patterns: useState for local state, useEffect for side effects and lifecycle, useRef for DOM refs and mutable values, useContext for dependency injection without prop drilling, useReducer for complex state logic, and custom hook creation. Synthetic events, event pooling, context API with createContext and Provider, memoisation with React.memo, useMemo, and useCallback, portals for rendering outside the DOM tree, and the rules of hooks explained.
App Router vs Pages Router comparison covering file-based routing, layouts, and templates. Server and client component rules with the "use client" directive, data fetching patterns with fetch and Route Handlers, caching behaviour and revalidation strategies, middleware for request rewriting and authentication, Server Actions for form handling without API routes, static and dynamic metadata generation, and ISR for incremental static regeneration.
Composition API with script setup syntax covering ref, reactive, computed, and watch. Built-in directives including v-model modifiers, v-for keying and iteration, and v-if/v-show conditional rendering. Slots (default, named, scoped) for component composition. Lifecycle hooks from onMounted to onUnmounted. Pinia store setup with state, getters, and actions. Teleport for modal/overlay rendering, provide/inject for deep prop passing, and TypeScript integration with defineProps and defineEmits.
Layout utilities with flexbox and grid, spacing and sizing scale, typography system with font smoothing, colour palette customisation and arbitrary values, responsive breakpoint prefixes (sm/md/lg/xl/2xl), dark mode with class-based toggling, state variant prefixes for hover/focus/active/group/peer, arbitrary property and value syntax using square brackets, and tailwind.config.js setup with content paths, theme extensions, and plugin registration.
HTTP methods with idempotency and safety semantics, status code ranges from 1xx to 5xx with the most common codes explained, resource naming conventions following RESTful URL patterns, pagination strategies including cursor and offset-based with response format examples, filtering and sorting query parameter conventions, request and response header patterns for content negotiation and caching, standardised error response structure, and authentication schemes including Basic, Bearer, and API keys.
FastAPI and Flask side by side covering route decorators and path parameters, request parsing with Pydantic models vs Flask request objects, dependency injection with Depends vs Flask-SQLAlchemy scoped sessions, middleware and error handling patterns, blueprints and APIRouter for modular organisation, marshmallow serialisation with schema validation, async endpoint support in FastAPI, WebSocket handling in both frameworks, and testing with TestClient.
Express and NestJS side by side covering middleware chains with next(), error handling middleware patterns, file upload with multer configuration, JWT authentication with passport strategies and guards, NestJS controllers and providers with dependency injection, DTO validation with class-validator and class-transformer, exception filters for structured error responses, guards and interceptors for cross-cutting concerns, and WebSocket gateway setup with Socket.IO.
MariaDB database administration — connection and user management, CREATE/ALTER/DROP tables with column types and constraints, CRUD queries with SELECT/INSERT/UPDATE/DELETE, JOIN types (INNER, LEFT, RIGHT, CROSS), indexing strategies for query performance, EXPLAIN query analysis, transaction control with COMMIT/ROLLBACK, stored procedures and triggers, backup and restore with mysqldump, and performance tuning with slow query logs.
MongoDB document database — CRUD operations with insertOne/find/updateOne/deleteOne, query operators ($gt, $in, $regex, $elemMatch), indexing (single, compound, text, geospatial), aggregation pipeline with $match/$group/$sort/$lookup, schema design patterns (embedding vs referencing), replica sets for high availability, sharding for horizontal scaling, MongoDB Atlas cloud setup, and Mongoose ODM with schemas and validation for Node.js.
MySQL relational database — installation and configuration, database and table creation with column types (INT, VARCHAR, TEXT, JSON), SELECT queries with WHERE/ORDER BY/GROUP BY/HAVING, JOIN operations, subqueries and derived tables, CREATE INDEX and EXPLAIN for query optimisation, stored procedures and functions, triggers and events, user privileges and GRANT/REVOKE, backup strategies with mysqldump and binary logs, and InnoDB vs MyISAM storage engine comparison.
PostgreSQL database — psql CLI with \d, \dt, \di meta-commands, CREATE TABLE with SERIAL and UUID primary keys, advanced data types (JSONB, arrays, ranges, ENUM), full-text search with tsvector/tsquery, indexing (B-tree, GIN, GiST, BRIN), CTEs and window functions, EXPLAIN ANALYZE for query planning, VACUUM and autovacuum tuning, pg_hba.conf authentication, connection pooling with PgBouncer, and backup/restore with pg_dump and pg_restore.
Prisma ORM for TypeScript/Node.js — schema.prisma with datasource, generator, and model definitions, relations (1:1, 1:m, m:n) with @relation, CRUD operations with prisma.user.findMany/create/update/delete, filtering with where/contains/startsWith/IN, pagination with skip/take/cursor, aggregation with count/avg/sum, migrations with prisma migrate dev/deploy, Prisma Client setup, and connection pooling for production deployments.
Everything you need to run LLMs locally with Ollama — installation on Linux, macOS, Windows, and Docker, quick-start commands, CLI reference with all commands and environment variables, Modelfile creation with key parameters, REST API examples with curl and Python, popular models table (Llama, Mistral, Qwen, DeepSeek and more), integration guides for Open WebUI, Continue.dev, AnythingLLM, and LangChain, plus a VRAM requirements table with the warning that 70B models need 40+ GB of VRAM, troubleshooting, and tips.
Query syntax with variables, aliases, and operation names, mutations with input types and return payloads, subscriptions for real-time data with event iterators, fragments and inline fragments for reusable field selections, Apollo Client setup with useQuery, useMutation, and useSubscription hooks, cache policies including InMemoryCache field policies and type policies, schema definition language with custom scalars and directives, error handling with partial results, and pagination with offset, cursor, and relay connection patterns.
MonoBehaviour lifecycle with Awake, OnEnable, Start, Update, FixedUpdate, LateUpdate, and OnDisable ordering. Coroutines with WaitForSeconds, WaitUntil, and custom yield instructions. Rigidbody force modes (Force, Impulse, VelocityChange, Acceleration), Collider types (Box, Sphere, Capsule, Mesh, Terrain), triggers vs colliders with OnTriggerEnter/OnCollisionEnter callbacks, raycasting with RaycastHit for 3D and 2D, serialization attributes like SerializeField, HideInInspector, and System.Serializable, and ScriptableObject data containers for shared configuration and event channels.
Event graph with Construction Script, BeginPlay, and Tick, Branch and Sequence nodes for control flow, Cast To nodes for type-safe access, Blueprint Interfaces for communication between unrelated actors, Animation Blueprint state machines with blend spaces for locomotion, Timelines for value interpolation over time, variable exposure flags for instance-editable, and nativization for performance optimisation in production builds.
Scene tree with get_node and the $ shorthand for path-based access, signals with connect, emit, and one-shot flags, _process and _physics_process separation with delta timing, Tween nodes and SceneTreeTween for animated value transitions with easing curves, @export for inspector-exposed variables with type hints and ranges, Input handling with Input.get_action_strength and InputEvent, and packed scene instantiation with .tscn resource loading.
Game config with type, width, height, physics, and scene arrays. Scene lifecycle with init for data passing, preload for asset loading, create for setup, and update for game loop. Arcade physics with colliders, overlaps, and groups for efficient collision checks. Keyboard input with cursors and key objects, pointer input for tap, drag, and multi-touch. Asset loading with load.image, load.spritesheet, and load.audio, spritesheet animation creation with anims.create and play.
App builder with add_plugins, add_systems, and add_event. Component definitions as data-only structs implementing the Component trait. Commands for spawning and despawning entities with bundles. Query filters including With, Without, Changed, Added, and Or for system parameter constraints. Resources as singleton globals with insert and remove, system scheduling with .chain() for ordering and label-based .before/.after, and EventWriter/EventReader for decoupled cross-system communication.
Viewport navigation with gizmo, numpad shortcuts for orthographic views, and fly/walk modes. Selection with border, circle, and lasso, mesh editing operations including Extrude (E), Loop Cut (Ctrl+R), Bevel (Ctrl+B), Inset (I), and Knife (K). Modifier stack with Subdivision Surface, Mirror for symmetry, Boolean for CSG operations, Array for patterns, and Decimate for LOD. UV unwrapping with Smart UV Project and Seam-based unwrapping, texture baking for normal maps and ambient occlusion, and export presets for FBX and GLTF with transform settings.
Aseprite shortcuts for drawing tools (Pencil, Eraser, Fill, Blur), selection with Marquee, Lasso, and Wand, and layer management with blend modes and opacity. Palette management with hue-shifting colour ramps, shading with cell-shading and dithering patterns. Animation with frame-by-frame, onion skinning for ghost overlays, and tag-based animation state looping. Export settings for sprite sheets with JSON and XML data, GIF optimisation with frame delay and dithering, and indexed PNG with colour count constraints.
PBR map reference covering albedo (diffuse), normal (bump direction), roughness (microsurface), metallic (conductivity), ambient occlusion (shadow contact), and height/displacement (parallax). Packed texture formats including ORM (Occlusion/Roughness/Metallic) and ARM (Ambient/Roughness/Metallic) for shader efficiency. UV tiling with texture density in texels per metre, file format comparison for PNG vs TGA vs EXR with compression and bit depth, and baking checklist for normal, AO, curvature, and thickness maps from high-poly to low-poly.
FBX for animation and skinning with Unity/Unreal import settings including scale and rotation compensation. GLTF/GLB for web-based engines with embedded textures, morph targets, and Draco mesh compression. OBJ for simple geometry interchange with MTL material references. USDZ for Apple ecosystem with AR Quick Look. Blender export presets with transform apply, axis conversion (Y-up vs Z-up), n-gon triangulation, and vertex colour handling. Scaling reference for unit system mismatch between DCC tools and engines.
Rigidbody properties including mass, drag, angular drag, interpolation, and constraints. Force modes explained: Force for continuous, Impulse for instantaneous, VelocityChange for direct velocity, and Acceleration for ignoring mass. Collider types with best-fit geometry, triggers vs colliders for detection without physics push. Collision detection modes: Discrete for low-speed, Continuous for high-speed collisions, and Continuous Dynamic for fast objects vs static tiles. Layer-based collision matrix setup, Physics Material with friction and bounciness, and performance tips for collision optimisation with sleep threshold and compound colliders.
CharacterController movement with Move and SimpleMove, jumping with velocity accumulation, and slope limit for angled surfaces. Rigidbody force-based characters using AddForce with ForceMode for momentum and air control. WheelCollider suspension setup with spring, damper, and target position, friction curves with extremum and asymptote values, motor torque for acceleration, steering angle for turning, and brake torque for stopping. Raycast-based custom suspension for off-road and physics-replicating vehicles with spring force calculation and wheel visual alignment.
FixedJoint for permanently connecting two rigidbodies, HingeJoint with motor torque for rotation, soft spring limits, and angle-based min/max constraints. SpringJoint with rest length, stiffness, and damping for elastic connections. CharacterJoint with twist and swing limits for humanoid ragdolls, ConfigurableJoint as the universal joint covering all constraint types including linear and angular motion limits, drives for target position and rotation, and projection for joint correction. Ragdoll activation scripts with bone mapping and death force thresholds, performance considerations for joint-heavy scenes with solver iteration counts.
Enum-based FSMs with switch statements for simple state transitions, class-based FSMs using the State pattern with Enter/Update/Exit methods. Unity Animator State Machines with parameters (float, int, bool, trigger), transitions with exit time and conditions, and blend trees for smooth locomotion blending. Behavior Trees with Selector (OR) and Sequence (AND) composite nodes, Decorator nodes for inversion and repetition, and leaf nodes for actions and conditions. Blackboard data store for shared variables across tree nodes, and decision criteria for choosing between FSM, HSM, Behaviour Trees, and Utility AI for different NPC types.
Unity NavMesh baking with agent radius, height, and slope settings, NavMeshAgent API for pathfinding with SetDestination, stopping distance, and speed. Off-mesh links for jumps, drops, and climbing, area types with cost multipliers for terrain preference. Waypoint patrol systems with point arrays and cyclic/random/ping-pong traversal patterns. A* grid-based pathfinding with Manhattan and Euclidean heuristics, path smoothing with string pulling, and dynamic obstacle updates. NavMeshObstacle carving for moving obstacles that update the NavMesh in real time.
Perlin noise with octave stacking for fractal Brownian motion (FBM) terrain and biome blending with multi-layer noise, cellular automata with birth/survival rules and smoothing passes for cave generation, L-systems with axiom, production rules, and turtle graphics for tree and plant branching structures. Weighted spawn tables with rarity tiers and cumulative probability selection, seed management with System.Random seeded generation for deterministic reproducible worlds, and biome assignment with temperature and moisture gradient maps and edge blending with falloff curves.
Scripted smooth follow with interpolation damping and dead-zone thresholds for 2D and 3D cameras, Cinemachine virtual cameras with Priority-based switching, Body/Composer framing for target centering, Aim/GroupComposer for multi-target, and noise shake profiles for impacts. Orthographic vs perspective matrix comparison for 2D and 3D games, multi-camera switching with blend types (cut, ease, lerp), and cutscene camera sequences with animated look-at targets and timeline integration for cinematic transitions.
Directional, point, and spot light properties including range, intensity, colour temperature, and cookie textures. Shadow settings with resolution, cascade splitting for directional lights, and shadow bias for shadow acne and peter panning. Light modes: realtime for dynamic, mixed for static with dynamic shadows, and baked for performance with lightmap UVs. Post-processing volume override stack including Bloom for glow, Color Grading with lookup tables and curves, SSAO for contact shadows, Vignette for peripheral darkening, Depth of Field for focus effects, and Tonemapping for HDR to LDR conversion with ACES and neutral operators.
LOD groups with auto-generation from source meshes and cross-fade transitions for smooth distance-based detail switching. Occlusion culling with occlusion areas and portal/room data for large open worlds. Object pooling with Queue-based allocation and deactivation patterns for bullets, enemies, and particle effects. Static batching for immobile objects, dynamic batching for moving meshes under certain vertex limits, GPU instancing for identical meshes, and SRP Batcher for material property reuse. Profiling tools including the Profiler window, Frame Debugger for draw-call inspection, RenderDoc GPU capture, and target metrics baseline for 30fps mobile and 60fps desktop.
Unity AudioSource properties with 3D spatial blend, min/max distance rolloff, and doppler effect for positional audio. Audio Mixer groups for signal routing, snapshot system for ducking and environment transitions, and attenuation curves for distance-based volume. FMOD event system with parameter-driven variations, and Wwise event and game sync workflow with RTPCs for real-time parameter control. Decision guide for choosing between Unity Audio for simple projects, FMOD for rapid prototyping and designer workflow, and Wwise for AAA pipeline with extensive profiling and simulation tools.
The blueprint for your game project — what a GDD is and why vibe coders need one, core sections (overview, core loop, mechanics, story, art, audio, UI/UX, tech stack, milestones, monetization), GDD formats from one-pagers to wikis, AI prompt templates for generating and expanding GDD sections, common mistakes, recommended tools, and a complete GDD checklist.
World-space health bars with billboard transform and Canvas setup, damage decay animation with Image.fillAmount for gradual depletion. Floating damage numbers with TextMeshPro label pooling, colour-coded by type, and physics-free upward trajectory. Time-scale pause menus with TimescaleManager, input blocking with event system disable, and canvas sorting order layering. Input rebinding screens using the New Input System with action maps and composite bindings, validation listeners for conflict detection. Tooltip system with hover detection and delayed show/hide, UI-space minimap via RenderTexture with orthographic camera, and controller navigation with first/last selected button and event system axis override.
Setting up a homelab for vibe coding — hardware buying guide from £150 budget mini PCs to dual-GPU workstations, Proxmox hypervisor setup with VM/LXC layouts, essential self-hosted services (Ollama, Open WebUI, Gitea, Woodpecker CI, databases), networking with reverse proxies and VLANs, ZFS storage with snapshots and RAID, security hardening, power/cost considerations, and a complete £300 starter lab build.
Unity Input System with C# generated classes, action maps for input contexts, and callback events for button presses, values, and performed/cancelled states. Keyboard and mouse reading with WASD movement, Mouse.current.position for aiming, and scroll delta for zoom. Gamepad with left/right stick for movement and camera, and trigger buttons for actions. Haptic rumble with gamepad.SetMotorSpeeds for low and high frequency vibration. Axis smoothing with exponential moving average and dead zone configuration for stick centering. Runtime key rebinding with interactive rebinding UI and serialised binding overrides for persistent saves per user profile.
PlayerPrefs for simple settings storage with platform-specific registry and plist backing. JSON serialization with JsonUtility for MonoBehaviour compatibility and Newtonsoft Json.NET for dictionaries and nested structures. BinaryFormatter for fast serialization of complex object graphs with AES encryption using System.Security.Cryptography. Save slot management with metadata files for timestamps, play time, and screenshot thumbnails. Auto-save triggers on scene load and checkpoint reach, cloud save integration with PlayFab and Steam Cloud, and cross-platform file location handling with Application.persistentDataPath and Environment.SpecialFolder conventions.
ZFS storage for Linux and homelabs — pool creation with mirror/RAID-Z layouts, vdev selection guide and RAID-Z1 warnings for large HDDs, dataset management with key properties (compression, recordsize, quota), instant snapshots and clones, backup workflow with zfs send/recv over SSH, performance tuning (ARC RAM cache, L2ARC SSD cache, SLOG write cache with power-loss protection requirements, special vdevs), troubleshooting for degraded pools, CKSUM errors, and ARC RAM limits, plus 10 tips.