Browse All Prompts

Build a modular page builder using Gatsby 5 Slice API. Components: 1. Reusable slices for headers, footers, CTAs. 2. GraphQL queries for slice data. 3. Dynamic slice ordering via CMS. 4. Partial builds for changed slices only. 5. Preview mode for content editors. 6. A/B testing for slice variations. 7. Analytics tracking per slice. 8. Responsive image optimization. Integrate with Contentful or Sanity and use StaticImage for performance.

Use personalized video to stand out. When to use video: 1. High-value accounts (worth the time). 2. Multiple failed touch attempts. 3. Complex value prop (better shown than written). 4. Re-engagement of cold leads. Video structure (60-90 seconds): 1. Personalized intro (10s): 'Hi [Name], I'm [You]. I was looking at [Company]...' 2. Relevant observation (20s): '...and noticed you recently [trigger event]. Congrats!' 3. Value prop (20s): 'We help companies like yours [achieve outcome].' 4. Specific example (15s): 'For example, [Customer] saw [specific result].' 5. Call to action (5s): 'Would 15 minutes next week work to explore if this fits?' Production: use Loom or Vidyard, share screen showing their website/LinkedIn, show your face (builds trust), smile and be enthusiastic. Send via: email (embed thumbnail), LinkedIn message. Track: video view rate (60%+), watch time (>75%). Reply rate: typically 3-5x higher than text email.

Improve free trial conversion rates. Trial design: optimal length 14-30 days (long enough to see value, short enough to create urgency). Friction: minimal (credit card optional for PLG). Activation: define 'aha moment' (e.g., send first campaign, create first report). Drive to activation: Day 1: welcome email with quick-start guide. Day 2: in-app prompts to complete setup. Day 3: personal outreach from AE if high-value. Day 7: success check-in call. Day 10: case study email. Day 14: upgrade prompt with limited-time offer. Metrics: signup-to-activation rate (target 40%+), activation-to-paid rate (target 25-40%). Improve conversion: 1. Reduce time-to-value (better onboarding). 2. Demonstrate ROI during trial (analytics emails). 3. Offer incentives (20% off if paid before trial ends). 4. Human touch for enterprise (white-glove onboarding). 5. Remove friction from payment (one-click upgrade). Track where trial users drop off, optimize those moments.

Implement robust error handling in Remix. Patterns: 1. Route-level ErrorBoundary for unexpected errors. 2. useRouteError hook to access error details. 3. CatchBoundary for thrown responses (404, 401). 4. Nested error boundaries for granular recovery. 5. Custom error pages with helpful messages. 6. Error logging to external service. 7. Fallback UI with retry button. 8. Development vs production error display. Use loader error throwers for validation failures and graceful degradation.

Prevent churn for at-risk renewals. Identify at-risk signals: 1. Usage drop (30%+ decline). 2. Support ticket spike. 3. Champion left company. 4. NPS detractor response. 5. Decline QBR invitations. 6. 90 days to renewal. Intervention playbook: Day 1: Executive reach-out ('I noticed [usage drop]. What's going on?'). Day 7: Schedule rescue call with leadership team. Day 14: Present custom revival plan (address specific issues, quick wins, additional support). Day 30: Implement quick wins, show progress. Day 60: Review improvement, negotiate renewal terms. Negotiation leverage: multi-year commitment (lower price), pay-as-you-go (reduce risk), success-based pricing (align incentives). Last resort: pause option (3-month break, maintain data). Recovery tactics: assign new champion internally, executive sponsor program, dedicated CSM. Track save rate. Prevent: proactive usage monitoring, regular health checks, strong onboarding. Keeping customers cheaper than acquiring new ones.

Create comprehensive sales playbook for consistency. Sections: 1. ICP and Buyer Personas (who we sell to, pain points, motivations). 2. Value Propositions (core message, differentiation per persona). 3. Sales Process (stages, exit criteria, average time per stage). 4. Methodology (MEDDIC, Challenger, SPIN - which we use). 5. Prospecting (channels, scripts, templates, cadences). 6. Discovery Questions (by persona, problem area). 7. Demo Guidelines (structure, key features to show, customization tips). 8. Objection Handling (top 10 objections, proven responses). 9. Closing Techniques (negotiation tactics, discount policies). 10. Tools and Resources (CRM, sales engagement, enablement content). 11. Metrics and KPIs (what we measure, targets). Format: living Wiki or PDF, searchable, visual (screenshots, flowcharts). Ownership: sales ops maintains, reps contribute. Update: quarterly reviews. Usage: onboarding (week 1 reading), certification (test knowledge), ongoing reference.

Build reactive forms using Angular 17 signals. Implementation: 1. Signal-based form state management. 2. Computed validation rules with effect(). 3. Custom validators with async signals. 4. Real-time error messages. 5. Dirty/touched state tracking. 6. Form submission with loading states. 7. Field dependencies and conditional validation. 8. Accessibility with ARIA attributes. Use standalone components and inject FormBuilder. Display inline errors with smooth animations.

Build formal mentorship for skill development. Program structure: Pair senior reps (mentors) with new/struggling reps (mentees). Duration: 6 months. Commitment: 1 hour/week. Mentor selection: top performers, willingness to teach, communication skills. Matching: by skill gap (new rep with veteran), territory (same vertical for relevance), personality (assessment fit). Activities: 1. Call shadowing (mentor observes mentee, provides feedback). 2. Reverse shadowing (mentee watches mentor calls). 3. Role-playing (practice discovery, objection handling). 4. Deal reviews (strategy sessions on active opportunities). 5. Goal setting (monthly targets, skill development areas). 6. Book club (read sales books together). Accountability: shared tracker, manager check-ins, end-of-program presentation. Incentives: mentors get bonus or recognition, priority for promotions. Benefits: faster ramp time (3 months vs 6), higher quota attainment (10-15% lift), retention improvement. Mentee feedback drives mentor improvements.

Master voice techniques for phone sales. Tonality principles: 1. Vary pitch (avoid monotone, go up at questions, down at statements). 2. Enthusiasm (smile while talking, it changes voice). 3. Confidence (speak declaratively, not tentatively). 4. Match prospect (mirror their energy level). Pacing: speak 150-160 words per minute (conversational, not rushed). Slow down for: important points, pricing, next steps. Speed up for: less critical details. Use pauses: after asking question (don't fill silence), for emphasis (pause before key benefit). Vocal warmup: hum, tongue twisters, breathing exercises before call block. Record and review: identify filler words ('um', 'like', 'you know'), pitch patterns, pacing issues. Power words: 'exactly', 'absolutely', 'certainly' (show conviction). Avoid: 'I think', 'maybe', 'hopefully' (weaken message). Practice: read scripts aloud in different tones. Get feedback from manager. Tonality accounts for 38% of communication impact.

Leverage Solid.js's fine-grained reactivity for a metrics dashboard. Features: 1. createSignal for individual metrics. 2. createMemo for derived calculations. 3. createResource for async data fetching. 4. Live updates without virtual DOM overhead. 5. Multiple chart types (line, bar, pie). 6. Real-time WebSocket data streaming. 7. Granular updates only re-render changed cells. 8. Time range selector with transitions. Achieve 60fps performance with large datasets.

Leverage AI to augment sales efficiency. AI tool categories: 1. Conversation Intelligence (Gong, Chorus): call recording, transcription, coaching insights. 2. Email Writing (Lavender, Jasper): generate personalized emails at scale. 3. Prospecting (Clay, Apollo): enrich data, find lookalikes, trigger alerts. 4. Meeting Intelligence (Fireflies, Otter): transcribe meetings, auto-create follow-up tasks. 5. Lead Scoring (Madkudu, 6sense): predict conversion likelihood. Workflow integration: 1. Gong records all calls, highlights keywords, action items. 2. Clay enriches prospect list with company data, growth signals. 3. Jasper drafts personalized emails using prospect data. 4. Apollo sequences emails automatically. 5. Fireflies sends meeting summary to CRM. 6. Madkudu flags high-intent leads for priority follow-up. Human role: review AI outputs, add personal touch, strategic decisions. Time saved: 10-15 hours/week. ROI: higher activity (20% more outreach), better quality (personalization improves response 3x). Train reps on AI tools in onboarding.

Design a flipped classroom module for a high school subject. Pre-class (at home): 1. Create 10-15 minute instructional video (e.g., using Loom, Screencastify) explaining core concepts. 2. Assign short reading or simulation. 3. Embed 3-5 quiz questions in the video to check for understanding. In-class (active learning): 1. Start with a 5-min Q&A to clarify video concepts. 2. Group students for collaborative problem-solving activity (20 mins). 3. Facilitate a project-based learning task applying the concepts (15 mins). 4. Conclude with an exit ticket assessing application of knowledge. Example: for history, video on causes of WWI, in-class debate on responsibility.

Set up a Turborepo monorepo with shared components. Structure: 1. apps/ folder for Next.js and React apps. 2. packages/ui for shared component library. 3. packages/config for shared configs (ESLint, TS). 4. Parallel task execution with turbo run. 5. Remote caching for CI/CD speed. 6. Versioning with changesets. 7. Storybook for component documentation. 8. Testing with Vitest across packages. Use pnpm workspaces and implement proper dependency graphs.

Develop a 4-week Project-Based Learning (PBL) unit for middle school science. Driving Question: 'How can we, as student scientists, design a solution to reduce our school's carbon footprint?' Week 1: Entry event (documentary clip), research phase (causes of climate change). Week 2: Investigate local impact, interview school maintenance staff on energy use. Week 3: Brainstorm solutions (e.g., recycling program, energy-saving campaign), form expert groups. Week 4: Develop final product (presentation, proposal to principal, prototype), public exhibition of learning. Assessment: rubric for collaboration, critical thinking, final product quality. Integrate math (data analysis) and ELA (persuasive writing).

Design a 4-level rubric to assess critical thinking in student essays. Criteria: 1. Identifies and summarizes the problem/question. 2. Considers and evaluates multiple perspectives/sources. 3. Analyzes assumptions and evidence. 4. Develops a well-reasoned conclusion or hypothesis. Levels: 4-Exemplary (sophisticated analysis, questions assumptions, synthesizes info). 3-Proficient (clearly explains, considers other views, logical conclusion). 2-Developing (identifies problem superficially, relies on limited sources, conclusion is weak). 1-Beginning (misunderstands problem, uses personal opinion over evidence). Use clear, observable language. Share rubric with students before the assignment.

Create a resumable PWA using Qwik's unique architecture. Requirements: 1. Instant interactivity with 0 hydration. 2. Service worker for offline capability. 3. Lazy-load components on interaction. 4. Streaming SSR with early hints. 5. Smart prefetching based on viewport. 6. App shell pattern for navigation. 7. Push notifications integration. 8. Install prompt with custom UI. Use Qwik City for routing and resumability for instant TTI even on slow networks.

Create a differentiated lesson on fractions for a 4th-grade class. Tiered Activities: 1. Approaching-level group: use physical manipulatives (fraction bars) to find equivalent fractions. 2. On-level group: solve word problems involving adding fractions with like denominators. 3. Above-level group: create their own word problems involving adding and subtracting fractions with unlike denominators. Flexible Grouping: start with whole-group instruction, then break into tiered groups. Use formative assessment (quick whiteboard check) to adjust groups. Choice Boards: offer students choice in how they practice (e.g., Khan Academy, worksheet, or drawing models).

Design an inquiry-based lab for biology students. Phenomenon: Show students a video of spinach leaf disks floating in a bicarbonate solution under light. Driving Question: 'What factors affect the rate of photosynthesis in spinach leaves?' Student-led investigation: 1. Students brainstorm variables (light intensity, light color, CO2 concentration). 2. Groups design their own experiment to test one variable. 3. They write a procedure, identify controls, and predict outcomes. 4. Conduct experiment, collect data (e.g., time it takes for 50% of disks to float). 5. Analyze data, create graphs, and present findings to the class. Teacher acts as facilitator, providing materials and guiding questions.

Architect a data fetching layer with Nuxt 3 composables. Structure: 1. useFetch with key-based caching. 2. useAsyncData for complex queries. 3. Custom composable useApiClient. 4. Global error handling middleware. 5. Loading states with useLoadingIndicator. 6. Optimistic updates pattern. 7. Request deduplication. 8. Stale-while-revalidate strategy. Integrate Pinia for client-side state and implement automatic retries with exponential backoff.

Integrate Classcraft to gamify vocabulary for a 7th-grade ELA class. Setup: 1. Create student accounts (Mages, Warriors, Healers). 2. Define game rules: earn XP (Experience Points) for correct vocabulary quiz answers, lose HP (Health Points) for off-task behavior. 3. Create 'quests' where students use vocabulary words in sentences to defeat a 'monster'. 4. Reward system: students spend GP (Gold Pieces) on real-world privileges (e.g., 5 minutes of free time, listen to music while working). Weekly 'Boss Battle': a challenging vocabulary quiz where students collaborate using their character powers. Track progress on a public leaderboard to foster competition.

Outline a K-12 digital citizenship curriculum. Key Themes (by grade band): K-2 (Safety & Balance): online safety basics, screen time balance. 3-5 (Privacy & Communication): personal information, cyberbullying awareness, respectful online talk. 6-8 (Media Literacy & Digital Footprint): identifying fake news, understanding digital permanence, online reputation. 9-12 (Copyright & Activism): fair use, intellectual property, using social media for social good. Implementation: monthly lessons delivered by homeroom teachers, integrated into subject areas (e.g., citing sources in history), parent workshops, student-led campaigns. Use resources from Common Sense Media. Assess via scenarios and reflections.

Develop a custom Vite 5 plugin for specialized workflow. Plugin features: 1. Transform hook for custom file types. 2. Virtual modules for config injection. 3. HMR API for hot updates. 4. Dev server middleware. 5. Build hooks for asset processing. 6. SSR transform handling. 7. Dependency pre-bundling optimization. 8. Watch mode for external tools. Use TypeScript with proper plugin typing and implement configureServer for custom routes.

Facilitate a Socratic seminar for 'To Kill a Mockingbird'. Preparation: 1. Students read a specific section and prepare responses to open-ended questions (e.g., 'How does Harper Lee define courage?'). 2. Arrange classroom in a circle. Seminar Structure: 1. Set norms: listen actively, build on others' ideas, cite textual evidence. 2. Pose opening question. 3. Students lead discussion, teacher is a silent observer. 4. Inner/Outer Circle: half of students discuss for 15 mins while outer circle observes and takes notes on specific behaviors (e.g., use of evidence), then switch. 5. Closing: students reflect on the discussion and their understanding of the text. Assessment: based on participation quality, use of evidence, and listening skills, not quantity of talk.

Implement low-stakes formative assessments to guide instruction. 1. Exit Ticket: At end of lesson, ask students to answer 1-3 short questions on an index card (e.g., 'What was the most important concept today?' 'What question do you still have?'). Review before next class to identify misconceptions. 2. Think-Pair-Share: Pose a question. Give students 1 minute to think individually, 2 minutes to discuss with a partner, then call on pairs to share with the whole class. 3. Whiteboard Response: Have all students write their answer to a problem on mini-whiteboards and hold them up. Quickly scan for understanding. 4. Plickers/Kahoot: Use tech tools for quick, engaging quizzes. Use data to form small groups for re-teaching.

Implement progressive enhancement with htmx. Pattern: 1. Server-rendered HTML with hx-get attributes. 2. Partial page updates without full reload. 3. hx-trigger for various events (click, scroll, intersect). 4. hx-swap strategies (innerHTML, outerHTML, beforeend). 5. Loading indicators with hx-indicator. 6. Form validation with server-side logic. 7. WebSocket updates with hx-ws. 8. Graceful fallback for no-JS scenarios. Use with Express or Django for HTML-over-the-wire architecture.

Design a VR lesson for a world history class using Google Expeditions or similar platform. Objective: Students will identify key architectural features of the Colosseum and Roman Forum. Pre-VR Activity (10 mins): Introduce key vocabulary (arch, aqueduct, forum) and provide historical context. VR Experience (20 mins): 1. Guide students through a 360-degree tour of the Colosseum. 2. Pause at points of interest, asking questions ('What events took place here?' 'How does the architecture support a large crowd?'). 3. Move to the Roman Forum, have students identify different building types. Post-VR Activity (15 mins): Students write a 'postcard' from ancient Rome describing what they saw, or work in groups to build a model of a Roman structure.

Implement trauma-informed strategies to create a safe learning environment. Core Principles: Safety, Trustworthiness, Choice, Collaboration, Empowerment. Classroom Practices: 1. Predictable routines: post a daily schedule, use consistent procedures. 2. Create a 'calm-down corner' with sensory tools (stress balls, weighted lap pads). 3. Offer choice: allow students to choose their seat or how they demonstrate learning. 4. Build relationships: greet each student at the door, hold regular check-ins. 5. De-escalation techniques: use a calm tone, validate feelings ('I see you're frustrated'), provide space. 6. Avoid punitive discipline: focus on restorative conversations instead of punishment. Professional Development: train staff on the effects of trauma on learning and behavior.

Create accessible dropdowns with Alpine.js. Features: 1. x-data for component state. 2. x-show with transitions for visibility. 3. x-on:click.outside to close dropdown. 4. Keyboard navigation (Arrow, Enter, Esc). 5. x-bind for dynamic classes. 6. Focus trap within dropdown. 7. ARIA attributes for screen readers. 8. Multiple dropdown coordination. Use x-cloak to prevent flash and implement searchable dropdown with x-model for filter input.

Use Scratch to teach storytelling in a 5th-grade ELA class. Project: 'Animate a Narrative'. 1. Introduction (1 hour): Teach Scratch basics (sprites, backdrops, motion blocks, say blocks). 2. Storyboarding (1 hour): Students plan a short story with a beginning, middle, and end on paper. 3. Coding (3 hours): Students create their animated story in Scratch, programming characters to move and speak dialogue. 4. Peer Feedback (1 hour): Students share their projects and give 'two stars and a wish' feedback. 5. Revision (1 hour): Students revise their animations based on feedback. Assessment: rubric based on narrative structure, character development, and coding complexity (e.g., use of loops, conditional statements).

Establish a high school peer tutoring program. Phase 1 (Planning): 1. Identify need (e.g., high failure rates in Algebra 1). 2. Recruit tutors (B+ or higher, teacher recommendation). 3. Develop tutor training on communication, patience, and explaining concepts simply. Phase 2 (Implementation): 1. Match tutors and tutees based on subject and availability. 2. Schedule tutoring sessions (e.g., during study hall, after school). 3. Provide a dedicated space (library, classroom). 4. Create simple tracking forms for sessions. Phase 3 (Evaluation): 1. Monitor tutee grades and test scores. 2. Collect feedback from tutors, tutees, and teachers. 3. Celebrate success with recognition for tutors. Benefits: tutees get academic support, tutors reinforce their own learning and develop leadership skills.

Build a framework-agnostic design system with Lit. Components: 1. Custom elements with @customElement decorator. 2. Reactive properties with @property. 3. Shadow DOM for style encapsulation. 4. Slots for content projection. 5. CSS custom properties for theming. 6. Event dispatching with CustomEvent. 7. Form-associated custom elements. 8. TypeScript for type safety. Package as npm library, document with web-component-analyzer, and test with @web/test-runner.

Apply UDL principles to a lesson on the water cycle. 1. Multiple Means of Representation (the 'what'): Present information via text, video with captions, diagrams, and a hands-on model. 2. Multiple Means of Action & Expression (the 'how'): Allow students to demonstrate understanding by writing a paragraph, creating a comic strip, recording a short video explanation, or building a physical model. 3. Multiple Means of Engagement (the 'why'): Connect the topic to local weather patterns, allow students to choose a research topic (e.g., droughts, floods), and structure the task as a collaborative challenge. Goal: remove barriers to learning by providing flexible options for all students from the start.

Street photography shot of a futuristic cyberpunk Tokyo alleyway at night, neon rain reflecting on wet pavement, a cyborg street vendor cooking noodles, steam rising, vibrant teal and magenta lighting, cinematic lighting, shot on 35mm lens, f/1.8, high contrast, photorealistic, 8k --ar 16:9 --v 6.0 --style raw

Set up effective CI/CD pipeline. Stages: 1. Source (code commit triggers pipeline). 2. Build (compile, dependency installation). 3. Test (unit, integration, e2e tests). 4. Code Quality (linting, code coverage, SonarQube). 5. Security Scan (dependency vulnerabilities, SAST). 6. Deploy to Staging (automated). 7. Deploy to Production (manual approval or automated). Tools: GitHub Actions, GitLab CI, Jenkins, CircleCI. Use Docker for consistent environments. Parallel jobs for speed. Fail fast. Notifications on failure. Blue-green or canary deployments. Infrastructure as Code (Terraform). Measure: deployment frequency, lead time, MTTR.

Write effective code documentation. Levels: 1. Code comments (explain why, not what - complex logic only). 2. Function/method docs (parameters, return values, exceptions - JSDoc, docstrings). 3. README (setup, usage, examples). 4. API documentation (OpenAPI/Swagger for REST). 5. Architecture docs (system design, diagrams). 6. Changelog (version history). Best practices: Keep docs close to code. Update with code changes. Use examples. Avoid obvious comments. Document assumptions and edge cases. Use diagrams (C4 model, UML). Tools: Sphinx, Doxygen, MkDocs. Good code is self-documenting, but docs add context.

Design microservices architecture effectively. Principles: 1. Single Responsibility (one service, one business capability). 2. Decentralized Data (each service owns its database). 3. API Gateway (single entry point). 4. Service Discovery (Consul, Eureka). 5. Asynchronous Communication (message queues, events). 6. Circuit Breaker (fault tolerance). 7. Containerization (Docker, Kubernetes). Challenges: distributed tracing, data consistency, testing. Use API versioning. Implement health checks. Centralized logging (ELK). Monitoring (Prometheus, Grafana). Start with monolith, extract services gradually. Not always the right choice - consider team size and complexity.

Apply design patterns to solve common problems. Creational: 1. Singleton (single instance). 2. Factory (object creation). 3. Builder (complex object construction). Structural: 4. Adapter (interface compatibility). 5. Decorator (add behavior dynamically). 6. Facade (simplified interface). Behavioral: 7. Observer (event notification). 8. Strategy (interchangeable algorithms). 9. Command (encapsulate requests). 10. Template Method (algorithm skeleton). Don't force patterns - use when appropriate. Understand problem first. Patterns improve communication ('let's use Observer here'). Study Gang of Four book. Practice with real examples.

Optimize application performance systematically. Techniques: 1. Profile first (identify bottlenecks with profiler). 2. Database optimization (indexes, query optimization, connection pooling). 3. Caching (Redis, Memcached, CDN). 4. Lazy loading (load data on demand). 5. Code-level optimization (efficient algorithms, avoid premature optimization). 6. Asynchronous processing (queues, background jobs). 7. Minification and compression (gzip, Brotli). Frontend: bundle splitting, image optimization, tree shaking. Backend: horizontal scaling, load balancing. Measure impact (before/after metrics). Use APM tools (New Relic, Datadog). 80/20 rule: optimize the 20% causing 80% slowness.

Secure your applications against common vulnerabilities. OWASP Top 10: 1. Injection (SQL, NoSQL, OS commands - use parameterized queries). 2. Broken Authentication (implement MFA, secure password storage with bcrypt). 3. Sensitive Data Exposure (encrypt data at rest and in transit, HTTPS). 4. XML External Entities (disable XXE in parsers). 5. Broken Access Control (enforce authorization checks). 6. Security Misconfiguration (disable debug mode, update dependencies). 7. XSS (sanitize user input, use CSP headers). 8. Insecure Deserialization (validate serialized data). 9. Using Components with Known Vulnerabilities (dependency scanning). 10. Insufficient Logging (log security events). Use security headers, rate limiting.

Refactor code safely and effectively. Common refactorings: 1. Extract Method (long function → smaller functions). 2. Rename Variable (unclear → descriptive). 3. Extract Class (large class → multiple focused classes). 4. Inline Method (unnecessary abstraction). 5. Replace Magic Numbers with Constants. 6. Introduce Parameter Object (long parameter lists). 7. Replace Conditional with Polymorphism. When to refactor: before adding features, during code review, when fixing bugs. Red-Green-Refactor cycle. Use IDE refactoring tools. Keep tests green. Small steps. Commit after each refactoring. Based on Martin Fowler's 'Refactoring' book.

Design efficient database schemas. Normalization forms: 1. 1NF (atomic values, no repeating groups). 2. 2NF (no partial dependencies). 3. 3NF (no transitive dependencies). Balance normalization with performance (denormalize for read-heavy). Design principles: Use surrogate keys (auto-increment IDs). Foreign keys for relationships. Indexes on frequently queried columns. Avoid NULL when possible. Use appropriate data types. Naming conventions (plural table names, singular columns). Document relationships (ERD diagrams). Consider ACID properties. Use constraints (UNIQUE, NOT NULL, CHECK). Plan for scalability (partitioning, sharding).

Master Git for effective collaboration. Workflow: 1. Feature branches (git checkout -b feature/new-feature). 2. Commit often with clear messages (feat:, fix:, docs:). 3. Pull before push (git pull --rebase). 4. Code review via pull requests. 5. Squash commits before merge. 6. Delete merged branches. 7. Tag releases (v1.0.0). Commit message format: type(scope): subject. Use .gitignore. Never commit secrets. Interactive rebase for clean history (git rebase -i). Resolve conflicts carefully. Use git stash for WIP. Learn: git log, git blame, git bisect. Branching strategies: Git Flow, GitHub Flow.

Design clean RESTful APIs. Principles: 1. Use nouns for resources (/users, not /getUsers). 2. HTTP methods: GET (read), POST (create), PUT (update), DELETE (delete). 3. Proper status codes (200 OK, 201 Created, 400 Bad Request, 404 Not Found, 500 Server Error). 4. Versioning (/v1/users). 5. Filtering, sorting, pagination (?page=2&sort=name). 6. HATEOAS (include links to related resources). 7. Consistent naming (camelCase or snake_case). Use JSON. Stateless requests. Authentication with JWT/OAuth. Rate limiting. Comprehensive documentation (OpenAPI/Swagger). Error messages should be helpful.

Write effective unit tests with TDD approach. TDD cycle: 1. Red (write failing test). 2. Green (write minimal code to pass). 3. Refactor (improve code while keeping tests green). Best practices: Test one thing per test. Use AAA pattern (Arrange, Act, Assert). Descriptive test names (should_returnTrue_when_inputIsValid). Mock external dependencies. Aim for 80%+ code coverage. Fast tests (<1 sec). Independent tests (no order dependency). Use test fixtures for setup. Frameworks: Jest, Pytest, JUnit. Benefits: confidence in changes, living documentation, better design.

Write maintainable code using SOLID principles. Principles: 1. Single Responsibility (class has one reason to change). 2. Open/Closed (open for extension, closed for modification). 3. Liskov Substitution (subclasses should be substitutable for base classes). 4. Interface Segregation (many specific interfaces > one general). 5. Dependency Inversion (depend on abstractions, not concretions). Additional: DRY (Don't Repeat Yourself), KISS (Keep It Simple), YAGNI (You Aren't Gonna Need It). Use meaningful names. Functions should be small (<20 lines). Comments explain why, not what. Refactor regularly. Code is read 10x more than written.

Debug efficiently with systematic approach. Process: 1. Reproduce the bug consistently. 2. Isolate the problem (binary search through code). 3. Form hypothesis about cause. 4. Test hypothesis (add logging, use debugger). 5. Fix the root cause, not symptoms. 6. Verify fix doesn't break other functionality. 7. Add test to prevent regression. Techniques: rubber duck debugging, print statements, breakpoints, stack traces. Read error messages carefully. Check recent changes (git blame). Search Stack Overflow. Take breaks if stuck. Document solution. Prevention: write tests first, code reviews, static analysis.

Master common algorithm patterns for coding interviews. Patterns: 1. Two Pointers (sorted arrays, palindromes). 2. Sliding Window (subarray problems, max/min in window). 3. Fast & Slow Pointers (cycle detection in linked lists). 4. Merge Intervals (overlapping ranges). 5. Cyclic Sort (missing numbers in range). 6. In-place Reversal (linked list reversal). 7. BFS/DFS (tree/graph traversal). 8. Binary Search (sorted data, optimization problems). 9. Top K Elements (heaps, quickselect). 10. Dynamic Programming (optimization, counting). For each pattern: recognize problem type, apply template, practice 5-10 problems. Use LeetCode, HackerRank.

Conduct thorough code reviews with this checklist. Areas to review: 1. Functionality (does it work as intended? edge cases handled?). 2. Code quality (readable, maintainable, follows style guide). 3. Tests (adequate coverage, meaningful assertions). 4. Performance (no obvious bottlenecks, efficient algorithms). 5. Security (input validation, no SQL injection, XSS prevention). 6. Documentation (comments for complex logic, README updates). 7. Error handling (graceful failures, logging). 8. Dependencies (necessary, up-to-date, no vulnerabilities). Use constructive feedback. Suggest improvements, don't just criticize. Automate with linters. Aim for 200-400 LOC per review. Balance thoroughness with speed.

Optimize productivity by managing energy, not just time. Framework: 1. Identify your peak energy hours (track for 1 week). 2. Schedule deep work during peak times. 3. Batch low-energy tasks (emails, admin) during slumps. 4. Take strategic breaks (90-min work cycles). 5. Manage physical energy (nutrition, hydration, movement). 6. Manage emotional energy (positive people, gratitude). 7. Manage mental energy (single-tasking, minimize decisions). Most people peak mid-morning. Post-lunch dip is normal. Use ultradian rhythms. Protect your best hours. Energy > time for productivity. Based on 'The Power of Full Engagement'.

Master active listening for better relationships and communication. Techniques: 1. Give full attention (put phone away, make eye contact). 2. Don't interrupt or plan response while listening. 3. Use verbal affirmations ('I see', 'go on'). 4. Paraphrase to confirm understanding ('So what you're saying is...'). 5. Ask open-ended questions. 6. Notice non-verbal cues (body language, tone). 7. Suspend judgment. Empathize before problem-solving. Listen to understand, not to respond. 80/20 rule: listen 80%, talk 20%. Improves relationships, reduces conflicts, builds trust. Practice in all conversations.