Search for a command to run...
Software developer documenting my journey through web and mobile development. I share what I learn, build, and struggle with—from React to SwiftUI, architecture decisions to deployment challenges. Not an expert, just passionate about coding and learning in public. Join me as I navigate the tech landscape one commit at a time.
No comments yet. Be the first to comment.
Daily code discoveries from my developer journey. Each post delivers concise, actionable insights I've uncovered while building with React, Typescript, and more. Brief but impactful lessons for curious developers looking to grow incrementally.
Ever tried swapping LocalStorage for Dexie DB in your Angular app? That was me yesterday—surrounded by coffee cups, error messages, and regret. My Angular service was tightly coupled to LocalStorage like peanut butter to jelly. Changing to Dexie mean...
The Backstory So there I was, staring at my shiny new Passbolt installation on Ubuntu 24.04, when that familiar dread crept in: "What happens when (not if) something goes wrong?" After one too many "I'll set up backups tomorrow" moments, I finally de...
TL;DR The custom Reactotron transport for react-native-logs improves logging by handling various message types, adding metadata, and allowing custom prefixes, making your logs more informative and easier to manage. The Backstory Logging is a crucial ...
TL;DR Add parallel: N to your GitLab CI job and pass --shard=${CI_NODE_INDEX}/${CI_NODE_TOTAL} to Playwright to slash your test execution time and keep your team shipping fast. The Backstory Last week, our test suite execution time crossed the dreade...
Error messages are often the first interaction users have with your support system. When they're cryptic, technical, or in the wrong language, they create confusion rather than clarity. That's why I built the Appwrite Exceptions Translator - a lightw...
You've probably experienced this frustration: you ask Claude, Cursor, or any AI coding assistant to write a function, and it confidently generates code that looks perfect at first glance. But when you try to run it, you discover missing imports, undefined variables, or subtle syntax errors that your IDE would have caught immediately with those familiar red squiggles.
The fundamental issue? AI assistants like Claude work with raw text. They don't have the semantic understanding of code that your IDE provides through Language Server Protocol (LSP). They can't see what symbols are actually defined in your codebase, which imports are missing, or where functions are actually located across your project files.
This is where Serena comes in—and it might just be the missing piece that transforms how AI assistants handle code.
Serena is an open-source coding agent toolkit developed by Oraios AI that bridges this critical gap. Instead of treating code as plain text, Serena leverages the same Language Server Protocol that powers your IDE's intelligence features.
Think about what your IDE can do:
Jump to definitions across multiple files
Find all references to a function or class
Auto-complete with context-aware suggestions
Show you errors before you even run the code
Navigate complex codebases with semantic understanding
Serena brings these exact capabilities to AI assistants through LSP integration. When Claude uses Serena, it's no longer flying blind—it can actually "see" your codebase the way a seasoned developer using a professional IDE would.
At its core, Serena implements the Model Context Protocol (MCP), which allows it to integrate seamlessly with Claude and other AI assistants. Here's what happens under the hood:
Serena starts language servers for your project (supporting Python, TypeScript, JavaScript, Java, C#, Go, Rust, and more). These are the same language servers your IDE uses—like Pyright for Python or TypeScript Language Server for TypeScript.
Instead of basic text manipulation, Serena provides tools that understand your code structure:
find_symbol: Locate function definitions, classes, or variables across your entire project
find_references: See where a symbol is used throughout your codebase
goto_definition: Navigate to the exact location where something is defined
Smart editing tools that understand code context, not just string patterns
For large projects, Serena can index your codebase upfront, making semantic operations lightning-fast. This means Claude can efficiently explore massive codebases without getting lost.
Serena includes a memory system that allows it to learn about your project over time, storing insights that can be recalled in future sessions.
Let me illustrate with a concrete example:
Without Serena:
You: "Add error handling to the user authentication function"
Claude: *Writes code but has to guess where the function is located,
what it's called, what imports it needs, and how it's structured*
Result: You spend time correcting the details
With Serena:
You: "Add error handling to the user authentication function"
Claude: *Uses find_symbol to locate authenticate_user() in auth/handlers.py,
analyzes its current implementation using goto_definition,
finds all references to understand usage patterns,
makes precise edits with full context awareness*
Result: The changes work immediately because Claude knew exactly
what was there
The beauty of Serena is its simplicity. If you're using Claude Code or Claude Desktop, you can integrate Serena in minutes:
bash
# Using uvx (recommended)
uvx --from git+https://github.com/oraios/serena serena start-mcp-server
bash
claude mcp add serena -- uvx --from git+https://github.com/oraios/serena \
serena start-mcp-server --context ide-assistant --project $(pwd)
Add this to your claude_desktop_config.json:
json
{
"mcpServers": {
"serena": {
"command": "/path/to/uvx",
"args": [
"--from",
"git+https://github.com/oraios/serena",
"serena",
"start-mcp-server"
]
}
}
}
Once configured, simply activate your project in conversation:
You: "Activate /path/to/my/project as a project using Serena"
What makes Serena truly powerful is how it enables sophisticated workflows:
Ask Claude to explore your codebase: "Show me all the database models" or "Find everywhere we make HTTP requests." With Serena's LSP tools, Claude can traverse your project's symbol graph.
"Rename this function and update all references"—Serena ensures nothing breaks because it knows about every usage.
Claude can trace execution paths, find function definitions, and understand call hierarchies to help diagnose issues.
Generate documentation that's accurate because Claude can verify what symbols actually exist and how they're used.
The difference between text-based AI coding and LSP-aware coding is like the difference between editing code in Notepad versus a modern IDE. It's a fundamental leap in capability.
Serena represents a shift in how we think about AI coding assistants:
From guessing to knowing: No more hallucinated imports or phantom functions
From text to semantics: Understanding code structure, not just patterns
From surface-level to deep: Navigating complex codebases with confidence
Being open source and free, Serena offers several benefits:
No vendor lock-in: Works with Claude's free tier and can integrate with other LLMs through Agno
Transparency: You can see exactly what tools Claude is using and how
Extensibility: Add custom tools or language servers as needed
Community-driven: Actively developed with contributions from developers worldwide
Cost-effective: No subscription fees on top of your Claude usage
Serena currently provides robust support for:
Full Support:
Python (via Pyright/Jedi)
TypeScript/JavaScript (via TypeScript Language Server)
Java (via Eclipse JDT Language Server)
C# (via OmniSharp/Roslyn)
Go (via gopls)
Rust (via rust-analyzer)
C/C++ (via clangd)
Ruby (via Solargraph)
And more...
Each language server brings IDE-level intelligence to Claude, adapted through Serena's unified interface.
Serena is highly configurable through YAML files:
Different tool sets for different environments:
ide-assistant: For integration with IDEs like VS Code or Cursor
desktop-app: For Claude Desktop usage
codex: For command-line coding with Codex CLI
chatgpt: For use with ChatGPT (via MCPO)
Operational patterns:
planning: Focus on code exploration and analysis
editing: Emphasis on code modification tools
interactive: Balanced tool set for conversation
one-shot: Optimized for single-task completions
You can create custom contexts and modes by adding YAML files to ~/.serena/.
For production or sensitive environments, Serena can be configured with security in mind:
yaml
# In .serena/project.yml
excluded_tools:
- execute_shell_command # Disable command execution
read_only: true # Prevent file modifications
This allows you to use Serena's analysis capabilities without granting write access.
For large codebases, indexing is crucial:
bash
# Index your project before first use
uvx --from git+https://github.com/oraios/serena serena project index
This creates a symbolic index that dramatically speeds up symbol lookup and reference finding operations.
Serena is under active development, with the team working on:
Enhanced LSP features (debugging via DAP, better diagnostics)
Jetbrains extension for seamless IDE integration
Additional language server support
Performance optimizations for massive codebases
The project is sponsored by Microsoft's Visual Studio Code team and GitHub Open Source, signaling strong industry interest in this approach.
The "missing piece" that Serena provides isn't just about better code generation—it's about closing what the developers call the "cognitive perception-action loop."
When an AI assistant can perceive code the way a developer does (through semantic understanding) and act on it with precision (through LSP-aware tools), it transforms from a clever text generator into a genuine coding partner.
If you've been frustrated by AI assistants that generate plausible-but-broken code, if you've wished Claude could actually understand your project structure, or if you're tired of manually fixing imports and references—Serena might be exactly what you've been looking for.
And the best part? It's free, open source, and integrates with Claude in just a few commands.
Resources: