AI Engineer at IBM · Open-source builder · Technical leader · Developer educator

I build production-minded AI systems that connect agents, tools, enterprise knowledge, and thoughtful user experiences. Across 13+ years in software engineering, I have worked from Android and frontend platforms to cloud-native full-stack systems, and now focus deeply on agentic AI, RAG, developer tooling, and AI product engineering.

I have also led teams of 20+ engineers and enjoy turning complex engineering concepts into practical tools, articles, and videos.

Turning coffee ☕ into code, and code into “works on my machine™”.

GitHub · Twitter / X · LinkedIn · Stack Overflow · Medium · DEV Community · YouTube

• 13+ years building software across mobile, web, backend, cloud, and AI
• Led engineering teams of 20+ developers
• 25K+ Stack Overflow reputation, with 2.5M+ people reached and 400+ answers
• Building local-first assistants, RAG systems, multi-agent platforms, and developer tools
• Creating AI Foundations for Developers, a practical video series that explains AI from first principles
• Interested in open-source collaboration, technical leadership, and ambitious product ideas

• Agentic AI: LangGraph, LangChain, A2A, MCP, tool calling, sub-agents, and human-in-the-loop workflows
• RAG and knowledge systems: document ingestion, embeddings, hybrid retrieval, vector databases, evaluation, and grounded generation
• AI product engineering: streaming interfaces, durable memory, approvals, observability, privacy, and local models
• System design: TypeScript and Python services, APIs, data systems, microservices, and cloud-native deployment
• Developer experience: reusable libraries, architecture tools, automation, testing, and documentation that explains the trade-offs

I would love to collaborate with developers interested in AI agents, developer tooling, testing, documentation, frontend engineering, accessibility, and local-first systems.

Good contributions are not limited to large features. Reproducible bug reports, tests, examples, documentation improvements, accessibility fixes, and developer-experience refinements are all valuable.

A local-first AI assistant built with TypeScript, React, LangGraph, A2A, Ollama, and a multi-service architecture.

• Streams answer text, artifacts, task state, and tool-call timelines
• Uses explicit approval gates before risky actions
• Supports persistent memory, web research, sandboxed code execution, and image generation
• Includes document chat with Docling parsing and hybrid retrieval
• Ships with architecture documentation, automated tests, and CI

A developer workbench for building, testing, and debugging Agent2Agent protocol servers.

• Interactive agent chat and execution-event inspection
• Agent library, task explorer, conversation management, and run comparison
• Automated QA suites and a headless test runner
• Embeddable React hooks and components for A2A applications
• Distributed as an npm-executable developer tool

A spec-aware, local-first editor for IBM Cloud architecture diagrams.

• Framework-independent TypeScript engine with semantic diagram elements
• IBM Cloud icon catalog, validation rules, templates, and quick fixes
• Web, VS Code, desktop, MCP, and agent-driven authoring surfaces
• Git-friendly .icad format with SVG and PNG export
• Accessibility-first design targeting WCAG 2.1 AA

An open-core concept for converting LLM-friendly Markdown into native DOCX, PDF, PPTX, and XLSX deliverables through one validated, template-driven engine.

I am language- and framework-pragmatic: I choose tools based on the problem, constraints, and operational environment rather than loyalty to a single stack.

A video and article series for software engineers who want to understand modern AI systems from first principles—not only learn another framework.

Topics include:

• Vectors and embeddings
• Dense vs. sparse retrieval
• Vector databases and Milvus
• Hybrid search and RAG
• LangChain integrations
• AI agents, memory, MCP, and A2A

Watch the YouTube series · Read on DEV · Read on Medium

1. Start with the user problem, not the framework.
2. Design explicit boundaries between models, tools, data, and UI.
3. Treat evaluation, observability, security, accessibility, and failure handling as product features.
4. Prefer local-first systems and open standards where they improve control and interoperability.
5. Document the reasoning, trade-offs, and operational path—not only the happy-path code.
6. Help teams grow through ownership, mentoring, constructive reviews, and clear technical direction.

• Reliable multi-agent systems and orchestration patterns
• Agent interoperability through A2A and MCP
• Local and private AI infrastructure
• AI-native developer tools and generated interfaces
• Retrieval quality, evaluation, and production RAG
• Making complex AI capabilities understandable and useful

I am open to conversations about AI engineering roles, technical leadership, open-source collaboration, agent architecture, RAG systems, developer tooling, and product ideas worth turning into working software.

LinkedIn · Twitter / X · Stack Overflow · Medium · DEV · YouTube