As a frontend developer, implement the LoginHero section for the Login page. This section uses Three.js (via `useRef` + `useEffect`) to render a WebGL canvas with: a tilted `TorusGeometry` orbit ring (color `0x1C2A48`, opacity 0.65), an outer dashed ring (opacity 0.35), an orbiting accent dot (`SphereGeometry`, color `0x00FFAB`), and 60 spherically distributed particles (`BufferGeometry` with `PointsMaterial`, color `0x00FFAB`). A `THREE.Clock`-driven animation loop animates ring rotation and dot orbiting. GSAP is imported for potential entrance animations. A responsive resize handler updates renderer size, pixel ratio, and camera aspect ratio on window resize. Refs used: `canvasRef`, `containerRef`, `taglineRef`, `trustRef`, `logoRef`. Mount the `<canvas ref={canvasRef}>` inside a parent container div. Apply LoginHero.css for layout positioning of the 3D canvas alongside tagline and trust indicator elements.
As a frontend developer, implement the LoginForm section for the Login page. This section renders a `<section className='lf-root'>` containing an `lf-card` div (ref `cardRef`) with a GSAP entrance animation (`gsap.to` — opacity 1, y 0, duration 0.6, ease `power3.out`, delay 0.15) that respects `prefers-reduced-motion`. State hooks managed: `email`, `password`, `rememberMe`, `showPassword`, `isSubmitting`, `errors` (object), `apiError` (string). Includes: `validateForm()` with email regex and password length checks; `handleSubmit()` async handler that simulates a 1200ms API call then redirects to `/Dashboard` on success or sets `apiError` on failure; `handleOAuth(provider)` redirecting to `/api/auth/{provider}`; `handleInputChange(field, value)` that clears per-field errors and `apiError` on input. JSX includes: `lf-header` with SVG icon, email input with error display, password input with `showPassword` toggle, `rememberMe` checkbox, Forgot Password link, submit button with `isSubmitting` spinner state, OAuth buttons (at minimum Google/GitHub via `handleOAuth`), and an `apiError` display block. Apply LoginForm.css for card shadow, input focus states, and button styles. Wire up real auth endpoint replacing the simulated `setTimeout`.
As a frontend developer, implement the LoginFooter section for the Login page. This section renders a `<footer className='lft-root' role='contentinfo'>` containing: an `lft-divider` decorative hr-like element; an `lft-content` div with two child elements — (1) a `<nav className='lft-links' aria-label='Footer navigation'>` that maps over `footerLinks` array (`[{label, href}]` for Privacy Policy `/Privacy`, Terms of Service `/Terms`, Contact Support `mailto:support@ramai.app`) rendering `<a className='lft-link'>` elements separated by `<span className='lft-separator'>` dot characters; (2) a `<div className='lft-social' aria-label='Social media links'>` mapping over `socialLinks` array (`[{label, href, icon}]` for LinkedIn, GitHub, Twitter) rendering `<a className='lft-social-link' target='_blank' rel='noopener noreferrer'>` each containing a `SocialIcon` component. The `SocialIcon` component renders inline SVG icons via `viewBox='0 0 24 24'` stroke-based paths for linkedin, github, and twitter icon variants. Apply LoginFooter.css for layout, link hover states, and social icon sizing. Note: a similar Footer component may already exist from other pages — reuse if available.
As a frontend developer, implement the CodingAssistantSidebar section for the CodingAssistant page. Build the `<aside className="cas-sidebar">` component with: (1) Brand header showing 'CA' icon badge, 'RAMAI' text and 'Code Assist' subtitle; (2) 'New Session' button with SVG plus icon; (3) Conversation history list with `conversationHistory` data grouped into 'Today', 'Yesterday', 'Earlier' groups — each group collapsible via `toggleGroup` using `collapsedGroups` state, with hover state tracked via `hoveredConv` useState; (4) Language selector dropdown using `languageOpen` useState, `selectedLanguage` useState (default 'python'), rendering `languageOptions` array with colored dot classes like `cas-selector-dot--python`; (5) Model selector dropdown using `modelOpen` useState, `selectedModel` useState (default 'gpt54'), rendering `modelOptions` with badge classes like `cas-model-badge--gpt` and `cas-model-badge--claude`. Note: this sidebar component may be reusable across sessions; check if a similar component exists from prior pages.
As a frontend developer, implement the CodingAssistantTopBar section for the CodingAssistant page. Build the `<div className="cotb-root">` component with: (1) Left region — an inline-editable session title using `title` useState (default 'Debugging React Component'), `isEditing` useState, `editValue` useState, and `inputRef` useRef; clicking the `cotb-session-title` span activates an `<input>` field that auto-focuses and selects all text via `useEffect`; commit on blur or Enter key, cancel on Escape, with a `cotb-edit-hint` span showing 'click to rename'; (2) Right region — a language badge with `cotb-lang-dot` and 'JavaScript' label; a token usage progress bar group with `cotb-token-bar-fill` styled via inline `width: ${tokenUsage}%` (42%) and label showing '4.2K / 10K'; a model pill showing 'GPT-4 Turbo' with `cotb-model-dot`; Share and Settings SVG icon buttons (`cotb-btn--share`, `cotb-btn--settings`). `cotb-divider` spans separate right-region items.
As a frontend developer, implement the CodingAssistantMain section for the CodingAssistant page. This is a 3D/canvas-heavy section using `@react-three/fiber`, `@react-three/drei`, `three`, and `gsap`. Build: (1) `HexLogo` sub-component — a `<mesh>` with `THREE.ExtrudeGeometry` built from a hexagonal `THREE.Shape` (radius 1.2, 6 vertices), extruded with bevel settings, using `meshStandardMaterial` (color `#00FFAB`, metalness 0.3, roughness 0.15, emissive intensity 0.35) and `lineSegments` edge overlay; animated with `gsap.to` rotating y by `Math.PI * 2` and x by `Math.PI * 0.5` on a 20s infinite linear loop via `meshRef` useRef; shape memoized with `useMemo`; (2) Idle/empty state rendering a `<Canvas>` with `OrbitControls`, ambient + point lights, and the `HexLogo` component, surrounded by a greeting heading and `SUGGESTIONS` chip array (`bug`, `zap`, `alert-circle`, `refresh-cw`) rendered via `SvgIcon` sub-component with inline SVG path mappings; (3) Chat message thread state managed via `useState` displaying user and assistant message bubbles with syntax-highlighted code blocks; uses `useRef` for scroll container and `useEffect` for auto-scroll.
As a frontend developer, implement the CodingAssistantInput section for the CodingAssistant page. Build the `<div className="cai-root">` component with: (1) A `<textarea ref={textareaRef}>` with `message` useState, auto-resize via `autoResize` useCallback that sets `el.style.height` to `Math.min(el.scrollHeight, 120)px`, triggered by `useEffect` on message change; `MAX_CHARS = 8192` limit enforced in `handleChange`; Enter key (without Shift) triggers `handleSend` via `handleKeyDown`; (2) Character counter `<span>` with dynamic class `cai-char-counter`, gains `cai-warning` class when `charCount >= MAX_CHARS * 0.9` and `cai-danger` at limit; (3) Attach button using `PAPERCLIP_SVG` constant that programmatically creates a hidden `<input type='file'>` accepting `.pdf,.txt,.md,.py,.js,.ts,.java,.cpp,.c,.h,.json,.yaml,.yml,.csv,.html,.css` with `multiple` support, triggered via `handleAttachClick`; (4) Send button using `SEND_SVG` constant, disabled when `isEmpty || isSending`, with `isSending` useState that simulates a 300ms send delay before resetting message and send state.
As a Backend Developer, implement authentication API endpoints using FastAPI: POST /api/auth/login (email+password), POST /api/auth/register, POST /api/auth/logout, GET /api/auth/me, POST /api/auth/refresh-token, POST /api/auth/forgot-password, POST /api/auth/reset-password, and OAuth redirect endpoints GET /api/auth/google and GET /api/auth/github. Use JWT tokens, bcrypt password hashing, and OAuth2 flow with Google/GitHub providers. Include rate limiting and input validation. Note: Frontend tasks LoginForm (b836b736) depends on these endpoints.
As a Backend Developer, create all MySQL/MariaDB database models and Alembic migrations for the RAMAI platform. Tables include: users (id, email, password_hash, name, role, avatar_url, created_at, updated_at), sessions (id, user_id, token, expires_at), attendance_records (id, user_id, subject, date, status, percentage), notes (id, user_id, title, content, source_pdf, flashcards_json, created_at), theory_answers (id, user_id, question, answer, format, created_at), resume_data (id, user_id, data_json, template, score, created_at), coding_sessions (id, user_id, language, code, analysis, created_at), roadmap_progress (id, user_id, roadmap_id, node_id, status, updated_at), placement_progress (id, user_id, challenge_id, status, score, completed_at), productivity_sessions (id, user_id, type, duration, goals_json, created_at). Generate all Alembic migration scripts.
As a Frontend Developer, set up global state management for the CodePilot AI web app using React Context or Zustand. Create stores/contexts for: AuthStore (currentUser, accessToken, isAuthenticated, login/logout actions), ThemeStore (darkMode toggle), NotificationStore (toast queue, push notifications), SessionStore (active coding session, selected language/model). Configure axios/fetch interceptors to inject JWT Bearer token on all API requests and handle 401 refresh-token flow. Set up React Router with protected routes that redirect unauthenticated users to /Login. This is a prerequisite for all frontend page implementations that make API calls.
As a Frontend Developer, establish the CodePilot AI design system: (1) Create a global CSS variables file defining all SRD colors (--primary: #0A0F29, --primary-light: #1C2A48, --secondary: #FF6F61, --accent: #00FFAB, --highlight: #FFD700, --bg: #121212, --surface: rgba(255,255,255,0.1), --text: #FFFFFF, --text-muted: #B0B0B0, --border: rgba(255,255,255,0.2)); (2) Set up global typography with modern fonts (e.g. Inter + JetBrains Mono for code); (3) Create reusable CSS utility classes for glassmorphism panels, neon glow effects, gradient buttons, and animated loading skeletons; (4) Create shared React components: GlassCard, NeonButton, LoadingSkeleton, ToastNotification, SidebarNav, BottomMobileNav, ProgressCircle, Modal. This is a prerequisite for all frontend page implementations.
As a frontend developer, implement the TheoryGeneratorHeader section for the TheoryGenerator page. This section renders a sticky navigation header with a fully interactive 3D graduation cap mesh built with @react-three/fiber. The GraduationCap component uses useRef/useMemo to compose a mortarboard (boxGeometry), cap base (cylinderGeometry), gold button (sphereGeometry with emissive #FFD700), tassel cord (cylinderGeometry with #FF6F61), tassel tip (sphereGeometry), and a glowing torus ring (emissive #00FFAB). The cap rotation responds to window scrollY via useEffect. The main TheoryGeneratorHeader component tracks scroll state (scrolled, scrollY), mobile menu open state (menuOpen), and a reveal animation flag (revealed). It uses refs (rootRef, titleRef, breadcrumbRef, descRef, iconRef) and drives entrance animations via GSAP on mount. The header shows a breadcrumb trail and a descriptive subtitle. The sticky shadow activates on scroll. Implement all CSS from TheoryGeneratorHeader.css including sticky positioning, reveal transitions, and Canvas sizing for the 3D element.
As an AI Engineer, set up LiteLLM for LLM routing between GPT-5.4 (user-friendly responses) and Claude 4.6 Opus (academic work) using Langchain as the orchestration layer. Create a unified AI service module with: route_ai_request(prompt, task_type) function that selects the appropriate model based on task type (coding/chat → GPT-5.4, theory/academic → Claude 4.6 Opus), streaming support, retry logic with exponential backoff, token usage tracking, and error handling. Expose internal async service used by all AI-powered API endpoints (theory generation, coding assistant, smart notes, resume builder).
As a Backend Developer, implement FastAPI authentication middleware: JWT token generation and validation (python-jose), OAuth2PasswordBearer dependency, get_current_user dependency injected into all protected routes, refresh token rotation logic, CORS configuration allowing frontend origin, and rate limiting middleware (slowapi). Create reusable FastAPI dependencies: require_auth, require_admin. This middleware underpins all backend API endpoints.
As a Tech Lead, verify the end-to-end integration between the Login page frontend implementation and the Auth backend API. Ensure the LoginForm (b836b736) correctly calls POST /api/auth/login and POST /api/auth/register, OAuth redirects to /api/auth/google and /api/auth/github work, JWT tokens are stored in the global AuthStore, protected routes redirect unauthenticated users, and error responses from the API (401, 422, 500) are displayed properly in the LoginForm UI. Validate the full login-to-dashboard redirect flow.
As a frontend developer, implement the TheoryGeneratorPromptInput section for the TheoryGenerator page. This section renders a large prompt textarea with MAX_CHARS=5000 and a WARN_THRESHOLD=4500. It manages state for value, isFocused, and glowPosition. A floating label (labelRef) animates via GSAP (y: -34, scale: 0.75, color: #00FFAB on focus/content; resets on blur/empty) with power2.out easing. A cursor-reactive glow tracks mouse position using handleMouseMove, computing x/y percentages relative to the wrapper bounding rect and passing them as CSS custom properties --glow-x/--glow-y. The clear button triggers a GSAP scale-bounce animation (scale 0.985, yoyo repeat) before resetting value and refocusing the textarea. The wrapper receives class tgpi-focused when active. The char count displays in tgpi-char-warn style when near limit. A decorative background blur orb (.tgpi-bg-blur) sits behind the container. Implement all CSS from TheoryGeneratorPromptInput.css including the radial glow effect driven by CSS variables.
As a frontend developer, implement the TheoryGeneratorPresets section for the TheoryGenerator page. This section renders a grid of preset prompt cards using a presets array of 8+ items (data-structures, algorithms, operating-systems, database-design, web-development, computer-networks, etc.), each with a Lucide icon (Binary, GitBranch, Cpu, Database, Globe, Network, Cog, BrainCircuit), title, description, prompt text, and category badge. It uses @react-three/fiber Canvas with @react-three/drei Float for a decorative 3D floating element. GSAP ScrollTrigger is registered and used to animate cards into view on scroll. Each card is clickable and includes a ChevronRight affordance. State tracks which preset is selected/hovered. Implement all CSS from TheoryGeneratorPresets.css including the card grid layout, category badges, hover glow effects, and ScrollTrigger entrance animations.
As a frontend developer, implement the TheoryGeneratorAdvancedOptions section for the TheoryGenerator page. This section is a collapsible accordion panel toggled by isOpen state. The header row shows a ChevronDown icon (rotates when open via th-ao-chevron--open class), a Settings icon, the title 'Advanced Options', and a badge toggling between 'Hide' and 'Configure'. The expandable body animates via inline style max-height (0px to contentHeight px, measured via bodyRef.current.scrollHeight in useEffect) and opacity, using cubic-bezier(0.4,0,0.2,1) transition. The inner grid contains: a Difficulty Level selector (Beginner/Intermediate/Advanced) with GraduationCap icon, a Response Length selector (Short/Medium/Detailed) with AlignLeft icon, Include Examples toggle (ListChecks icon), Include Diagrams toggle (GitBranch icon), and Output Format selector (Markdown/Plain Text/HTML) with FileCode icon. All five controls are tracked in state. Implement keyboard accessibility (Enter/Space toggles) and all CSS from TheoryGeneratorAdvancedOptions.css.
As a frontend developer, implement the TheoryGeneratorTipsSection section for the TheoryGenerator page. This section combines a @react-three/fiber Canvas with a TorusKnotScene (torusKnotGeometry args [1, 0.28, 100, 16], meshStandardMaterial color #00FFAB with emissive, opacity 0.85, transparent) and OrbitControls from @react-three/drei. GSAP animates the torus knot: emissiveIntensity pulses (0.6, yoyo, repeat -1, sine.inOut), groupRef.rotation.y spins 360° over 20s, and rotation.x oscillates (Math.PI*0.3, yoyo, sine.inOut). The UI renders a FAQ accordion with FAQ_ITEMS array (4 items: how answers are generated, editing, export formats, daily limits) — each item toggles open/closed via per-item state, with ChevronDown rotation animation. A PRO_TIPS list renders tip cards with Lightbulb/Sparkles/ArrowRight/MessageSquareHeart Lucide icons and highlighted keyword spans. useCallback optimizes toggle handlers. Implement all CSS from TheoryGeneratorTipsSection.css including accordion transitions, tip card styles, and Canvas positioning.
As a Backend Developer, implement FastAPI endpoints for the Theory Answer Generator: POST /api/theory/generate (accepts question, difficulty, length, include_examples, include_diagrams, output_format; routes to Claude 4.6 Opus via AI routing service; streams response), GET /api/theory/history (paginated list of user's generated answers), GET /api/theory/history/{id} (fetch single answer), DELETE /api/theory/history/{id}, POST /api/theory/export-pdf (generates and returns PDF using reportlab or weasyprint). All endpoints require JWT authentication. Note: Frontend TheoryGeneratorPreview (ea988ce0), TheoryGeneratorExportActions (6cba6718), and TheoryGeneratorAdvancedOptions (f564a0cb) depend on these endpoints.
As a Backend Developer, implement FastAPI endpoints for the AI Coding Assistant: POST /api/coding/analyze (accepts code, language; returns error detection, explanation, optimizations via GPT-5.4), POST /api/coding/chat (conversational coding assistant with session history), GET /api/coding/sessions (list user's coding sessions, paginated), GET /api/coding/sessions/{id}, DELETE /api/coding/sessions/{id}, POST /api/coding/sessions (create new session). Support streaming responses for chat. All endpoints require JWT auth. Note: Frontend CodingAssistantMain (b90acc14), CodingAssistantSidebar (081cd7d8) depend on these endpoints.
As a frontend developer, implement the TheoryGeneratorPreview section for the TheoryGenerator page. This is the most complex section, rendering a rich content preview panel. It uses DEMO_THEORY — an array of typed content blocks (h2, h3, p with inline HTML, code blocks with lang metadata, and list items) — to simulate generated output. A simple syntax highlighter tokenizes Python code using a PYTHON_KEYWORDS Set, coloring keywords, strings, and comments. State tracks activeTab (preview/raw), isGenerating (Loader2 spinner via GSAP pulse), and scroll position within the preview pane. Lucide icons used: Eye, FileText, Loader2, Zap, ArrowRight. GSAP animates the panel entrance and the generate button. The preview renders h2/h3 headings, paragraphs (dangerouslySetInnerHTML for bold tags), syntax-highlighted code blocks with language labels, and styled unordered lists. useMemo optimizes the rendered content tree. Implement all CSS from TheoryGeneratorPreview.css including tab bar, code block styling, and loading state.
As a Tech Lead, verify the end-to-end integration between the CodingAssistant frontend sections and the Coding Assistant backend API. Ensure CodingAssistantInput sends messages/code to POST /api/coding/chat with streaming, CodingAssistantMain renders streamed AI responses as chat bubbles with syntax highlighting, CodingAssistantSidebar loads conversation history from GET /api/coding/sessions and handles new session creation, and CodingAssistantTopBar reflects the active session's language/model. Validate that language and model selection from the sidebar are sent as parameters in API requests.
As a frontend developer, implement the TheoryGeneratorExportActions section for the TheoryGenerator page. This section features a @react-three/fiber Canvas background rendering a ParticlesField: an instancedMesh of PARTICLE_COUNT=80 circleGeometry particles with BufferAttribute positions and scales, animated each frame via requestAnimationFrame using THREE.Object3D/tempObject for matrix updates and THREE.Color lerpColors between #00FFAB and #1C2A48 for per-instance color. The main UI renders export action buttons (Copy, Download PDF, Share, etc.) with inline SVG icons including a custom IconSparkles component. GSAP animates button hover states and entrance. Each action button triggers a distinct callback with visual feedback. useCallback memoizes handlers. Implement all CSS from TheoryGeneratorExportActions.css including the Canvas overlay, button row layout, and hover glow effects.
As a Tech Lead, verify the end-to-end integration between the TheoryGenerator frontend sections and the Theory Generator backend API. Ensure TheoryGeneratorPromptInput submits questions to POST /api/theory/generate, streaming responses render correctly in TheoryGeneratorPreview, TheoryGeneratorAdvancedOptions parameters (difficulty, length, format) are passed in the API payload, TheoryGeneratorExportActions triggers POST /api/theory/export-pdf and downloads the file, and TheoryGeneratorPresets populate the prompt input correctly. Validate error states and loading indicators during generation.

Debug code w|
Six powerful AI-driven tools designed specifically for Computer Science students.
Detect errors, explain code, and get intelligent optimization suggestions powered by advanced AI.
Generate detailed theory answers instantly and export them as beautifully formatted PDFs.
Upload PDFs and let AI create intelligent summaries, flashcards, and study guides.
Track your attendance automatically and receive smart alerts when attendance drops low.
Build professional resumes with AI-generated templates tailored for tech careers.
Daily coding challenges, mock interviews, and curated roadmaps for placement success.
Hear from students who transformed their academic journey with CodePilot AI.
“CodePilot AI completely transformed how I prepare for placements. The AI coding assistant caught bugs I would have missed for hours.”
“The theory generator saved me countless hours before exams. It generates perfectly structured answers that are easy to revise.”
“Smart Notes is a game-changer. I upload my lecture PDFs and get flashcards instantly. My GPA jumped by a full point!”
Join thousands of students already using CodePilot AI to learn faster, code smarter, and land dream placements.
Get Started for Free→
No comments yet. Be the first!