* Scaling a FastAPI service from 0-10000 req/s was accomplished using the following optimizations:
* - Leveraging Python's asynchronous programming capabilities for non-blocking I/O operations with libraries like aio boto3 and httpx.
* - Optimizing read patterns by batching ScyllaDB queries into single requests to minimize network round-trips and prevent event loop stalls.
* - Minimizing data validation overhead using dataclasses instead of Pydantic models, especially when working with large volumes of data.
* - Improving garbage collection efficiency by fine-tuning Python's memory management settings for high-throughput applications.
* - Adopting a deployment strategy that utilizes topology spread constraints and node selectors to ensure optimal resource utilization in distributed systems.
These optimizations significantly improved the performance of the FastAPI service, including:
* Reduced p99 latency under 10ms
* Increased throughput by over 50%
* Improved overall system stability and reliability
# One-command setup for Claude Code with Laravel development
# Automatically configures all MCP servers for ultimate AI-powered Laravel experience with Figma integration
- Installs and configures Claude Code with complete development ecosystem
- GitHub integration
- Memory system
- Context7 (latest Laravel/PHP documentation access)
- Web fetch (access external APIs and resources)
- Figma integration (design-to-code workflows, automatic design token extraction)
- Filesystem access (read/write specific Laravel project files)
- Database integration (direct access to project's database)
- Laravel DebugBar (real-time debugging if installed)
- Design-to-code workflows with automatic design token extraction
- Automatic design token extraction for Tailwind CSS
- Interactive token management
- Laravel-specific design patterns and component generation
- Improved interactive detection
- Better token management
- Graceful error handling
- Smart fallbacks
- Figma usage guide
- Error handling documentation
- Laravel-specific workflows
- Robust configuration management
- Cross-platform compatibility
- Performance optimizations
* Add `zmodload zsh/zprof` to the top of your `.zshrc`
* Add `zprof` to the bottom of your `.zshrc`
* Use `DISABLE_AUTO_UPDATE="true"` and `DISABLE_MAGIC_FUNCTIONS="true"` at the top of your `.zshrc`
* Run `compinit -C` instead of `compinit` every day for faster completion
* Set `SPACESHIP_PROMPT_ASYNC=true` and `SPACESHIP_PROMPT_ADD_NEWLINE=true` in your `.zshrc`
* Remove unnecessary plugins from the list at the bottom of your `.zshrc`
* Use `ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE="20"` and `ZSH_AUTOSUGGEST_USE_ASYNC=1` for faster autosuggestions
* Consider using alternative shells like zinit or Pure prompt if you're not happy with your current setup
* Browserino is a tiny browser selector for MacOS written in SwiftUI.
* It allows setting as default browser and assigning shortcuts.
* It enables choosing which application to open links in.
* Inspired by great Browserosaurus but with improved performance and fixed Electron bugs.
* Can be installed via Homebrew with `brew tap AlexStrNik/Browserino` and `brew install browserino --no-quarantine`.
* Also available for download from the releases page.
* Supports monetization through Gumroad purchases.
⚠️ IMPORTANT NOTICE: Development focus has shifted to the MCP (Model Context Protocol) version of this workflow system. The MCP version provides enhanced features, real-time dashboard, and broader AI tool compatibility.🚀 View the new Spec Workflow MCP →
* Install globally `npm i -g @pimzino/claude-code-spec-workflow`
* Run setup command in your project directory `claude-code-spec-workflow`
* Complete `.claude/` structure - All files and directories
* 10 slash commands - 5 spec workflow + 5 bug fix workflow
* Intelligent task execution - Automated implementation
* 4 specialized agents - Enhanced automation
* Real-time dashboard - Monitor progress visually
* Auto-generated commands - One command per task
* Document templates - Professional spec documents
* Project steering - Persistent context and standards
* Smart optimization - Intelligent context sharing and caching
* # Building Reliable Agentic Systems: Part I
* *There’s always been a gap between demo and realistic application.*
* *With Gen AI, it has widened to a gulf.*
* *Agent demos accompanied by exaggerated claims are plentiful. Yet agentic success stories are thin on the ground, at least in enterprise.*
* *We can bridge the gap between promise and reality by applying what we’ve learnt about software engineering over time.*
* *Some things don’t change.*
* # Travel Planner Functionality
* *Tripper is a journey planner, originally created to plan a road trip for myself and my girlfriend.*
* *Given start and destination and desired dates, information about the travelers and a travel brief, it builds a personalized day to day plan.*
* *It suggests activities, chooses places to stay and searches Airbnb for each location.*
* # Supporting Services
* *Generating this quality of output requires not just LLMs, but multiple integrations.*
* *The supporting cast:*
* - Multiple LLMs: We need a high quality LLM for generating itinerary ideas and writing up the final proposal.*
* - Tools for LLMs to use. MCP tools (backed by Docker MCP gateway) for web search, Google maps and Airbnb; the Embabel platform built in math tool to allow distance and other calculations.*
* # The Hard Part: Making Tripper Reliable
* *You could throw all these tools at a large state of the art LLM and let it decide how to call them, in what a skeptical NVIDIA paper calls language model agency.*
* *Experience building Tripper showed that this would not produce acceptable results.*
* *Gotchas included:*
* - Invalid generated URLs.
* - Confusion around images.*
* - Inconsistent tool usage.*
* - Poor choice of tool arguments.*
# LogMerge GUI Application
* Merges and displays multiple log files in a single view, ordered chronologically by timestamp.
* Live log monitoring with auto-scrolling to follow the latest entries.
* Add log files individually or discover them recursively in directories with regex filtering for filenames.
* Plugin-based parsing system to support different log formats.
* Advanced filtering and search capabilities supporting discrete values, numeric ranges, text patterns (with regex), and time-based queries.
* Color-coded file identification for easy visual distinction.
* Configurable column display and ordering.
# Features
* Query and edit large codebases using advanced AI models with extended context support
* Generate applications from PDFs or sketches using multimodal AI
* Automate tasks like querying pull requests or handling complex rebases
* Connect external tools through MCP (Model Context Protocol)
* Support for multiple AI providers - both cloud and local
# MCP Chromautomation Service
* A comprehensive Model Context Protocol (MCP) service for Chrome browser automation with enhanced capabilities, built on the browserhttp library and using the mcp-go framework.
* Core Browser Automation:
* Enhanced Navigation: Navigate with performance tracking and advanced waiting
* Advanced Interaction: Click, type, select with improved reliability
* Content Extraction: Text, links, images, forms with metadata
* Session Management: Complete cookie and localStorage handling
* Screenshot Capture: Automated screenshot with custom naming
* New Analysis Tools:
* Performance Monitoring: DOM load times, network requests, resource analysis
* SEO Analysis: Title, description, keywords, heading structure
* Security Scanning: SSL validation, CSP analysis, vulnerability detection
* Content Intelligence: Comprehensive link categorization and form analysis
* Advanced Features:
* JSON API Integration: Send POST requests with browser context
* Local Storage Management: Read/write browser localStorage
* Multi-condition Waiting: Wait for elements, text, or navigation
* Session Cleanup: Complete cookie and storage clearing
* Interactive Menu: Navigate through options with keyboard
* Real-time Feedback: See results immediately
* Session Browser: View and manage saved sessions
* Request Logs: Monitor all browser activity
* Settings Panel: Database statistics and configuration
* Built on:
* browserhttp library - Real Chrome browser via chromedp
* JavaScript rendering and form submission
* Screenshot capture and storage
* Persistent tab management
* Press-and-hold a hotkey to transcribe your voice and paste the result wherever you're typing
* Hex is currently only available for Apple Silicon Macs
* The project has been opened-sourced, using WhisperKit for transcription and Swift Composable Architecture for structuring the app
## Tools
* `list_jobs`: Lists all available jobs on the Jenkins server with advanced filtering capabilities.
* `trigger_job`: Triggers a Jenkins job with optional parameters.
* `get_job_info`: Gets detailed information about a Jenkins job, including its parameters.
* `get_build_status`: Gets the status of a specific build.
* `get_console_log`: Retrieves the console log for a specific build.
* `list_artifacts`: List all artifacts for a specific Jenkins build.
* `download_artifact`: Download a specific build artifact content (text-based artifacts only).
* `search_artifacts`: Search for artifacts across recent builds of a job using pattern matching.
* `trigger_batch_jobs`: Trigger multiple Jenkins jobs in batch with parallel execution and priority queuing.
* `monitor_batch_operation`: Monitor the status of a batch operation and its individual jobs.
* `cancel_batch_operation`: Cancel a batch operation and optionally cancel running builds.
* A 100% free and open-source tool for AI pair programming that initializes web-based chatbots like ChatGPT, Claude, AI Studio or DeepSeek with your code and instructions, hands-free!
* Works with VS Code and its derivatives (Cursor, Windsurf, VSCodium, etc.).
* This repository defines a set of rules and practices for working with AI-powered coding tools
* Examples of such tools include:
- Aider.chat – A terminal-based, Git-integrated pair-programming assistant.
- Claude Code – Anthropic’s AI coding agent with deep project understanding and multi-file edits.
- Opencode – An open-source terminal UI coding agent that supports multiple LLMs and integrates with tools like Neovim.
* The repository outlines a spec-driven workflow
* Consistent prompting strategies and architecture-aware practices are defined within this repository
* To integrate CLAude Code with GLM-4.5 series models from Z.AI, select "Yes" when prompted for API key.
* Grant CLAude Code permission to access files in your folder.
* The default model is GLM-4.5; support for switching to other models is not currently available.
# Minimal Interface: Runs quietly in the background via the command line
# Triple-Tap Magic: Start/stop recording with a quick Ctrl triple-tap
# Auto-Paste: Text lands right where you need it, no extra clicks
# Audio Cues: Hear when recording begins and ends
# Mac Optimized: Harnesses Apple Silicon's MPS for blazing performance
# Top-Tier Models: Powered by NVIDIA NeMo and OpenAI Whisper
* Using an LLM to call tools in a loop is a simple way to create an agent, but it can lead to shallow agents that struggle with complex tasks.
* The DeepAgents library solves this limitation by implementing four key components:
+ A planning tool
+ Sub-agents
+ Access to a file system
+ A detailed prompt
* An MCP server that implements confirmation protocols between AI and users, providing tools for LLMs to request user confirmation when needed.
* A Model Context Protocol (MCP) server for AI-user confirmation and clarification, enabling reliable communication between AI assistants and users.
* Implements the Model Context Protocol Elicitation specification to enable confirmation and clarification protocols.
* Provides features such as confirming actions before execution, clarifying ambiguous requests, verifying understanding is correct, asking yes/no questions, collecting user satisfaction ratings, and custom confirmation dialogs.
* Supports development with GitHub Codespaces and configuration using environment variables.
* Intelligent timeout settings based on confirmation type are used, logging all confirmation interactions to a file for audit purposes.
* Supports integration with Claude Desktop and can be installed globally or used with npx.
* Written in TypeScript and runs on Node.js, compatible with @modelcontextprotocol/sdk ^1.0.0.
* Implements true MCP Elicitation protocol, enabling reliable communication between AI and users.
# Nanocoder CLI Coding Agent
* The Model Context Protocol (MCP) is an open standard for secure two-way connections between data sources and AI-powered tools
* Created a TypeScript MCP Server Starter with preconfigured TypeScript
* Includes features such as ESLint for clean code, integration test setup, and auto-import utility
* Goal of the starter kit is to skip boilerplate and make development easier
❌ Without XRAY
- ❌ "I can't see your code structure"
- ❌ "I don't know what depends on this function"
- ❌ Generic refactoring advice without impact analysis
- ❌ No understanding of symbol relationships
✅ With XRAY
- 🗺️ Map (explore_repo) - See project structure with symbol skeletons
- 🔍 Find (find_symbol) - Locate functions and classes with fuzzy search
- 💥 Impact (what_breaks) - Find where a symbol is referenced
# Agent Squad
## Overview
Flexible, lightweight open-source framework for orchestrating multiple AI agents to handle complex conversations.
- All CI workflows must pass before code changes may be reviewed. The existing code structure must not be changed without a strong reason.
- Every bug must be reproduced by a unit test before being fixed.
- Every new feature must be covered by a unit test before it is implemented.
- Minor inconsistencies and typos in the existing code may be fixed.
- The README.md file must explain the purpose of the repository.
- The README.md file must be free of typos, grammar mistakes, and broken English.
- The README.md file must be as short as possible and must not duplicate code documentation.
- Every class must have a supplementary docblock preceding it.
- A class docblock must explain the purpose of the class and provide usage examples.
- Every method and function must have a supplementary docblock preceding it.
- Docblocks must be written in English only, using UTF-8 encoding.
- Method bodies may not contain blank lines.
- Method and function bodies may not contain comments.
- Variable names must be single nouns, never compound or composite.
- Method names must be single verbs, never compound or composite.
- The principle of "Paired Brackets" suggested by Yegor Bugayenko must be respected.
- Error and log messages should not end with a period.
- Error and log messages must always be a single sentence, with no periods inside.
- Favor "fail fast" paradigm over "fail safe": throw exception earlier.
- Constructors may not contain any code except assignment statements.
- Implementation inheritance must be avoided at all costs (not to be confused with subtyping).
- Getters must be avoided, as they are symptoms of an anemic object model.
- The DDD paradigm must be respected.
- Elegant Objects design principles must be respected.
- Class names may not end with the -er suffix.
- Setters must be avoided, as they make objects mutable.
- Immutable objects must be favored over mutable ones.
- Every class may have only one primary constructor; any secondary constructor must delegate to it.
- Every class may encapsulate no more than four attributes.
- Every class must encapsulate at least one attribute.
- Utility classes are strictly prohibited.
- Static methods in classes are strictly prohibited.
- Method names must respect the CQRS principle: they must be either nouns or verbs.
- Classes must avoid using public static literals.
- Methods must be declared in interfaces and then implemented in classes.
- Public methods that do not implement an interface must be avoided.
- Methods must never return null.
- Methods should avoid checking incoming arguments for validity.
- null may not be passed as an argument.
- Type introspection and type casting are strictly prohibited.
- Reflection on object internals is strictly prohibited.
- All classes must be declared final, thus prohibiting inheritance.
- Exception messages must include as much context as possible.
- Every change must be covered by a unit test to guarantee repeatability.
- Every test case may contain only one assertion.
- In every test, the assertion must be the last statement.
- Test cases must be as short as possible.
- Every test must assert at least once.
- Each test file must have a one-to-one mapping with the feature file it tests.
- Every assertion must include a failure message that is a negatively toned claim about the error.
- Tests must use irregular inputs, such as non-ASCII strings.
- Tests may not share object attributes.
- Tests may not use setUp() or tearDown() idioms.
- Tests may not use static literals or other shared constants.
- Tests must be named as full English sentences, stating what the object under test does.
- Tests may not test functionality irrelevant to their stated purpose.
- Tests must close resources they use, such as file handlers, sockets, and database connections.
- Objects must not provide functionality used only by tests.
- Tests may not assert on side effects such as logging output.
- Tests may not check the behavior of setters, getters, or constructors.
- Tests must not clean up after themselves; instead, they must prepare a clean state at the start.
- Tests should not use mocks, favoring fake objects and stubs.
- The best tests consist of a single statement.
- Tests should use Hamcrest matchers if available.
- Each test must verify only one specific behavioral pattern of the object it tests.
- Tests must use random values as inputs.
- Tests should store temporary files in temporary directories, not in the codebase directory.
- Tests are not allowed to print any log messages.
- The testing framework must be configured to disable logging from the objects under test.
- Tests must not wait indefinitely for any event; they must always stop waiting on a timeout.
- Tests must verify object behavior in multi-threaded, concurrent environments.
- Tests must retry potentially flaky code blocks.
- Tests must assume the absence of an Internet connection.
- Tests may not assert on error messages or codes.
- Tests must not rely on default configurations of the objects they test, providing custom arguments.
- Tests must not mock the file system, sockets, or memory managers.
- Tests must use ephemeral TCP ports, generated using appropriate library functions.
- Tests should inline small fixtures instead of loading them from files.
- Tests should create large fixtures at runtime rather than store them in files.
- Tests may create supplementary fixture objects to avoid code duplication.
- Test method names must spell “cannot” and “dont” without apostrophes