- The real deadline isn’t when AI outsmarts us — it’s when we stop using our own minds.
- "Time under tension" in fitness (e.g., slower squats) builds more muscle; thinking benefits from a similar principle.
- Deep thinking requires sitting with disconnected ideas to combine them into something new.
- AI executives claim humans have 18 months before AI surpasses us in the workforce.
- The bigger concern isn’t AI taking jobs but humans degrading their own thinking abilities.
- AI is already affecting deep thinking, writing, and reading skills.
- Students increasingly use AI to cheat, leading to a decline in writing and critical thinking.
- Writing is thinking; outsourcing it to AI empties the mind of original thought.
- Reading scores are at a 32-year low, with many students unable to focus on long texts.
- Even elite college students struggle with reading full books or sustained focus.
- High schools have "chunkified" books to prepare for standardized tests, reducing deep reading.
- Writing and reading are essential for deep symbolic thinking, a key skill in the modern economy.
- AI is the latest threat to deep thinking, following TV, the internet, and smartphones.
- Literacy restructures human thought, enabling complex ideas; its decline unwires cognitive abilities.
- The skill to prioritize in the AI age: patience for long texts, holding conflicting ideas, and engaging deeply with writing.
- The author prepares their child for resilience and adaptability, emphasizing continuous learning.
- The author (who has ADD) uses AI as a tool to refine their own writing, not replace it.
- AI can be helpful if used to clarify thoughts, not to bypass thinking entirely.
- Welcome to OmniTools, a self-hosted web app offering a variety of online tools to simplify everyday tasks.
- Whether you are coding, manipulating images/videos, PDFs or crunching numbers, OmniTools has you covered.
- Please don't forget to star the repo to support us.
- All files are processed entirely on the client side: nothing ever leaves your device.
- The Docker image is super lightweight at just 28MB, making it fast to deploy and easy to self-host.
- Tools include:
- Image Resizer
- Image Converter
- Image Editor
- Video Trimmer
- Video Reverser
- And more...
- PDF Splitter
- PDF Merger
- PDF Editor
- And more...
- Case Converters
- List Shuffler
- Text Formatters
- And more...
- Date Calculators
- Time Zone Converters
- And more...
- Generate Prime Numbers
- Calculate voltage, current, or resistance
- And more...
- JSON Tools
- CSV Tools
- XML Tools
- And more...
- Open Computer Use is an open-source platform that gives AI agents real computer control through browser automation, terminal access, and desktop interaction
- Built for developers who want to create truly autonomous AI workflows
- Unlike traditional AI assistants that only talk about tasks, Open Computer Use enables AI agents to actually perform them by:
- 🌐 Browsing the web like a human (search, click, fill forms, extract data)
- 💻 Running terminal commands and managing files
- 🖱️ Controlling desktop applications with full UI automation
- 🤖 Multi-agent orchestration that breaks down complex tasks
- 🔄 Streaming execution with real-time feedback
- 🎯 100% open-source and self-hostable
- "Computer use" capabilities similar to Anthropic's Claude Computer Use, but fully open-source and extensible
- AI agent searching, navigating, and interacting with websites autonomously
- Executing commands, managing files, and running complex workflows
- Complex tasks broken down and executed by specialized agents
- Human-in-the-loop control and intelligent collaboration
- Open-source and self-hostable alternative to Vercel, Render, Netlify, etc.
- Build and deploy any app (Python, Node.js, PHP, etc.) with zero-downtime updates.
- Features: real-time logs, team management, customizable environments, and domains.
- Git-based deployments: Push to deploy from GitHub with zero-downtime rollouts and instant rollback.
- Multi-language support: Python, Node.js, PHP, or anything that can run on Docker.
- Environment management: Multiple environments with branch mapping and encrypted environment variables.
- Real-time monitoring: Live and searchable build and runtime logs.
- Team collaboration: Role-based access control with team invitations and permissions.
- Custom domains: Support for custom domains and automatic Let's Encrypt SSL certificates.
- Self-hosted and open source: Run on your own servers, MIT licensed.
- Server requirements: Ubuntu 20.04+ or Debian 11+ with SSH access and sudo privileges.
- Recommended DNS provider: Cloudflare.
- GitHub account required for GitHub App creation.
- Email provider: Resend account for login emails and invitations.
- Officially supported on Ubuntu/Debian; other distros may work but are not officially supported.
- Customizable infinite canvas dashboard with integrated Model Context Protocol (MCP) server support
- Open-source, self-hostable dashboard application with infinite, zoomable, and pannable canvas
- Unified interface for interacting with multiple MCP servers through a flexible, widget-based system
- Features:
- 🎨 Infinite Canvas: Organize workspace spatially with unlimited zoom and pan capabilities
- 🧩 Modular Widgets: 12+ pre-built widgets or create custom components
- 🛠️ No-code Widget Builder: Create widgets without coding
- 🤖 MCP Integration: Connect to multiple MCP servers using FastMCP library
- 🔌 AI-Powered: Configure multiple AI providers (OpenAI, Anthropic, Ollama, Google)
- 🎭 Template System: Save and share widget and dashboard configurations
- 🐳 Easy Deployment: One-command Docker setup or manual installation
- 🔒 Privacy-First: All data stays on your infrastructure, no external dependencies
- Highly opinionated, zero-configuration linter and formatter
- Ultracite is a preset for Biome, designed for consistent and type-safe code without configuration
- Why choose Ultracite?
- Zero-config by design
- Hundreds of rules for JavaScript/TypeScript optimization
- Customizable when needed
- Designed for humans and AI
- Ensures consistent code style and quality
- Reduces code review friction
- Agent integration for AI workflows
- Editor configuration generation
- Configurable spec with zero-config Biome
- MCP Support for remote linting/formatting
- VS Code output panel integration
- Works with popular IDEs and AI agents
- Enforce AI coding agents to follow team conventions and existing practices
- Centralized, shareable location with hierarchical inheritance for team conventions
- Encode best practices in YAML instead of plain-text documentation
- Works across multiple AI tools (Claude Code, Cursor, Gemini CLI)
- Qwen3-VL cookbooks coming soon, covering recognition, localization, document parsing, video understanding, and key information extraction.
- Cookbooks for various capabilities:
- **Omni Recognition**: Identify animals, plants, people, scenic spots, cars, merchandise, and more.
- **Powerful Document Parsing**: Parse text, layout position info, and Qwen HTML format.
- **Precise Object Grounding**: Supports relative position coordinates (boxes/points) for positioning and labeling.
- **General OCR & Key Info Extraction**: Strong text recognition in natural scenes/multiple languages; supports diverse key info extraction.
- **Video Understanding**: Better video OCR, long video understanding, and video grounding.
- **Mobile Agent**: Locate and think for mobile phone control.
- **Computer-Use Agent**: Locate and think for controlling computers and the web.
- **3D Grounding**: Accurate 3D bounding boxes for indoor/outdoor objects.
- **Thinking with Images**: Uses `image_zoom_in_tool` and `search_tool` for fine-grained visual detail comprehension.
- **MultiModal Coding**: Generate accurate code based on multimodal info.
- **Long Document Understanding**: Rigorous semantic comprehension of ultra-long documents.
- **Spatial Understanding**: See, understand, and reason about spatial information.
- Interactive find-and-replace terminal UI app.
- Recursively searches files in the current directory by default.
- Interactive Brokers MCP
- DeepSeek released a new paper called "DeepSeek OCR," which is more significant than a typical OCR model.
- Traditional vision LLM tokens were inefficient, often requiring more space than text tokens (e.g., 10k words → 15k tokens or 30k-60k visual tokens).
- DeepSeek achieved 10x better compression with vision tokens compared to text tokens (10k words → 1,500 compressed visual tokens).
- This aligns with human memory, where visual recall (e.g., book page layout) is often more efficient than textual recall.
- Unclear how this affects LLM reasoning—whether compressed visual tokens impact articulation or cognitive performance.
- Potential to expand context sizes significantly, especially when combined with sparse attention techniques.
- Google (Gemini) may already use similar methods, explaining its large context size and OCR efficiency, but keeps it secret.
- DeepSeek open-sourced their model, allowing public exploration and experimentation.
- Even with potential trade-offs (e.g., lossy attention), this could enable frontier LLMs with 10-20 million token context windows.
- Practical applications:
- Storing entire company documents in a prompt preamble for efficient querying.
- Caching entire codebases and updating them via git diffs.
- Analogy to physicist Hans Bethe, who memorized vast data for seamless problem-solving.
- This approach could expand working memory capacity by 10x or more.
- A macOS screensaver that plays live video streams.
- Supports YouTube videos and direct HLS streams.
- Also available: Android TV Live Screensaver.
- Turn any live stream into your screensaver/lockscreen.
- Comprehensive guide to offensive and defensive security for Large Language Models and Agentic AI Systems
- Systematic problem-solving framework for Claude Code CLI based on Princeton NLP research
- Tree of Thought (ToT) enables AI to solve complex problems through systematic exploration of solution spaces
- Generates multiple solution paths at each decision point
- Evaluates and compares different approaches systematically
- Backtracks and explores alternatives when paths don't work
- Finds optimal solutions through structured search
- AI agent designed to identify vulnerable employees susceptible to phishing attacks
- Uses public data sources to gather information and assess vulnerability
- Production-ready FastAPI template with Docker, CI/CD, observability, and one-click deployment to Render or Koyeb
- UV package management for faster, more reliable builds
- FastAPI with Python 3.12
- OpenAI released gpt-oss-120b and gpt-oss-20b, their first open-weight models since GPT-2 in 2019.
- These models can run locally with optimizations like MXFP4 quantization.
- The architecture builds on the transformer design but includes several modern tweaks.
- Key changes from GPT-2:
- Removal of dropout (no longer needed due to single-epoch training).
- Replacement of absolute positional embeddings with RoPE (Rotary Position Embedding).
- Swish/SwiGLU activation functions replace GELU for computational efficiency.
- Mixture-of-Experts (MoE) replaces single feed-forward modules for sparse activation.
- Grouped Query Attention (GQA) replaces Multi-Head Attention (MHA) for efficiency.
- Sliding window attention alternates with full-context layers to reduce compute costs.
- RMSNorm replaces LayerNorm for cheaper normalization.
- Comparison with Qwen3:
- gpt-oss is wider (larger embedding dimensions) while Qwen3 is deeper (more transformer blocks).
- gpt-oss uses fewer, larger experts (32 vs. 128 in Qwen3) but activates fewer per token (4 vs. 8).
- Both use GQA, but gpt-oss adds sliding window attention.
- gpt-oss includes attention bias units (rare in modern models) and attention sinks (learned per-head bias logits).
- Training details:
- Trained on mostly English, text-only datasets with a focus on STEM, coding, and general knowledge.
- Includes supervised fine-tuning and reinforcement learning stages.
- 2.1 million H100-hours for gpt-oss-120b (10x less for gpt-oss-20b).
- Reasoning capabilities:
- Supports adjustable reasoning effort (low/medium/high) via system prompts.
- Designed for tool use, potentially reducing reliance on memorization.
- MXFP4 optimization:
- Enables single-GPU inference (80GB H100 for 120B model, 16GB VRAM for 20B model).
- Requires RTX 50-series or newer for full efficiency (older GPUs supported with higher memory usage).
- Benchmarks:
- Competitive with proprietary models like GPT-5 and Qwen3 in reasoning tasks.
- Not yet listed on LM Arena leaderboard; early users report high hallucination rates.
- Licensing:
- Apache 2.0 license (open-weight, not full open-source).
- Allows commercial use and distillation into other models.
- GPT-5 context:
- Released shortly after gpt-oss, showing OpenAI’s open models are close to proprietary performance.
- Additional notes:
- Attention sinks stabilize long-context scenarios without modifying input tokens.
- Sliding window attention (128 tokens) is smaller than in other models (e.g., Gemma’s 1024 tokens).
- No base models released (only instruction-tuned versions), unlike Qwen3.
- CLI tool for scaffolding LLM creation and training
- Create production-ready LLM training projects in seconds
- Similar to create-next-app but for training custom language models
- AI-Powered Website Customization in Your Browser
- Magix is a powerful Chrome extension that lets you modify any website using natural language
- No coding required - just describe what you want, and watch as AI generates and applies the changes in real-time
- Think of it as ChatGPT meets Tampermonkey - the conversational intelligence of AI combined with the power of custom scripts
- 🎨 Customize Any Site - Dark mode for sites that don't have it, remove annoying elements, add missing features
- 💬 Chat-Based Interface - Iteratively improve your modifications through conversation
- 🔒 Privacy-First - Uses your own API keys, no data collection
- 🌐 Community Sharing - Discover and install modifications made by others
- ⚡ Instant Results - See changes applied in real-time
- OfflineAI is a privacy-optimized LLM coding agent.
- Works best with `Qwen3-Coder-30B-A3B-Instruct-UD-Q4_K_XL.gguf` on RTX 3090 or higher.
- Activate by clicking in source code and pressing `Ctrl+Alt+Shift+H` (for Help).
- OfflineAI Chat window opens; type a task and start with `Ctrl+Return`.
- Cancel tasks with the "Reset Chat History" button (top right).
- Agent never modifies files directly; shows diffs in the IDE.
- A compilation of professional principles and lessons learned from nearly a decade defending the internet from baddies at GitHub
- Practical Guidance for Security and Engineering Professionals
- Different principals have different strengths: deep expertise, horizontal influence, technical leadership, or cross-org alignment.
- Principals should remain hands-on, but their core role shifts to vision, design, sponsorship, and enabling others.
- Principals act as part-time PMs, engineers, designers, and more—nothing is outside their scope.
- More communication, influence, and cross-team collaboration are required; avoid shipping org charts to customers.
- Being right isn’t enough—you must convince others to act, build momentum, and secure sponsorship.
- Principals often teach the org to value new ideas, even if success rates are low (e.g., 3 out of 10 pitches).
- Focus on work that won’t happen without you—prototype, align orgs, or define long-term vision.
- Connecting teams, reusing solutions, and identifying growth opportunities can be more valuable than doing the work yourself.
- Scale impact by coaching and mentoring others; set aside time for office hours or regular syncs.
- Transition ownership to others—let them drive direction, even if their approach differs from yours.
- Create space in meetings for others to contribute; avoid dominating discussions.
- Silence in meetings can signal trust—if the team is on track, step back.
- In exec meetings, focus on meaningful questions and decisions only they can make.
- Guard your time—avoid becoming the "go-to" person for every meeting or review.
- If you can’t justify why a project needs a principal, reconsider its priority.
- Leverage organizational privilege to improve outcomes with minimal effort.
- Be mindful of your influence—casual comments may be overinterpreted.
- Always explain the "why" behind your decisions to prevent blind adherence.
- Stay connected with teams through reviews, demos, or informal interactions.
- Help teams see the bigger picture beyond day-to-day delivery.
- Balance big-picture thinking with pragmatic, local solutions.
- Decline low-quality feedback requests if you lack sufficient context.
- Engage with interns—early check-ins and meaningful projects can be transformative.
- Remove yourself from the critical path; empower others to take ownership.
- If promoted, continue what made you successful—engage with peers and define your focus.
- Autonomy comes with responsibility—choose high-leverage problems, not just what you prefer.
- Define your charter: owner (deep involvement), sponsor (alignment/drive), or consultant (guidance).
- Build a peer network—being a principal can feel isolating.
- Prioritize personal growth and well-being to avoid burnout.
- Keep learning—timebox stagnant projects and seek external knowledge (papers, prototypes).
- Single-stock analysis using Python and local machine learning/ AI tools (Ollama, LSTM). CC BY-NC-SA.
- Memmon restores window positions on external monitors for Mac.
- Limitations:
- Restores windows in other spaces only if the space is activated.
- Untested support for "Displays have separate Spaces" (issue #5).
- Requires macOS 10.10 or newer.
- Maximum strictness for Python projects, inspired by TypeScript’s --strict mode.
- Provides a `pyproject.toml` template and tooling configuration.
- SpacePigeon is a native macOS app (powered by Hammerspoon) that lets you define workspaces — which apps open, which desktop spaces they go to, and how windows are arranged.
- Effortlessly transition between workflows. SpacePigeon instantly orchestrates your applications, windows, and displays into the perfect environment for any task with a single click or hotkey.
- 🚀 One-Click Setup: Installs everything automatically. If you don't have Hammerspoon, SpacePigeon will download and install it for you.
- 🎨 Visual Configuration: A full native UI to manage your workspaces. No need to touch Lua code manually.
- 🖥 Multi-Monitor Support: Configure spaces and app layouts for both your Main and Secondary monitors.
- Provides agents with DOM Elements, CSS Rules, and Computed Style tools not available in chrome-devtools-mcp
- OpenScreen is a free, open-source alternative to Screen Studio for creating product demos and walkthroughs.
- Simpler than Screen Studio, covering basic features without a $29/month cost.
- Not a 1:1 clone; supports essential functionality for users who want control and no fees.
- 100% free for personal and commercial use; modify and distribute as needed (attribution appreciated).
- Features:
- Record full screen or specific apps.
- Manual zooms with customizable depth levels.
- Adjust zoom duration and position.
- Crop recordings to hide parts.
- Background options: wallpapers, solid colors, gradients, or custom images.
- Motion blur for smoother transitions.
- Add annotations (text, arrows, images).
- Trim video clips.
- Export in various aspect ratios and resolutions.
- Cloudflare’s November 18 outage postmortem sparked discussions about error handling, focusing on Rust’s `Result` and `unwrap`.
- `Result` in Rust can hold a success or error; `unwrap` extracts the success or crashes the program (similar to `assert`).
- Debate on `assert` in production misses the point—error handling is a global system property, not local.
- Error handling game: Decide if crashing (✅) or not (❌) is appropriate, with justifications provided.
- Three principles guide error handling decisions:
- **Correlated failures**: If failures are uncorrelated, crashing simplifies the system; if correlated, design to reject errors and continue.
- **Higher-layer handling**: Traditional architectures handle low error rates; fine-grained (e.g., serverless) handle higher rates, making crashing more acceptable.
- **Meaningful continuation**: Some systems (e.g., databases) must crash to avoid state corruption; others can use last-known-good versions.
- Error handling must be designed globally from the start; local decisions are insufficient.
- Blast radius reduction (e.g., cell-based architectures, shuffle sharding) limits damage from errors.
- `panic` (like `unwrap`) is treated as a crash here; Rust’s explicitness is better than C’s silent failures.
- Suggestions: Rename `unwrap` to `or_panic` or enforce justifications via lints (e.g., `clippy`).
- Powerful desktop application for extracting and filtering YouTube comments with advanced spam detection
- Built for researchers, data analysts, content creators, and anyone needing clean, actionable comment data
- Connects to YouTube Data API to fetch comments from any public video
- Autonomous Offensive/Defensive Research Framework
- RAPTOR: Recursive Autonomous Penetration Testing and Observation Robot
- Features:
- Scans code with Semgrep and CodeQL
- Fuzzes binaries with AFL
- Analyzes vulnerabilities using LLM reasoning
- Generates proof-of-concepts
- Patches vulnerabilities
- FFmpeg-specific patching
- OSS Forensics for GitHub investigations
- Agentic Skills Engine (SecOpsAgentKit)
- Structured reporting
- Like Playwright MCP but via extension
- 90% less context window
- 10x more capable (full playwright API)
- Coding standards and quality gates for product managers working with AI assistants in shared codebases
- PMs using AI to code face unique challenges: shipping value quickly without creating cleanup work for engineering teams
- My notes on NGINX administration basics, tips & tricks, caveats, and gotchas.
- Try for free at [screen.vision](https://screen.vision)
- Demo video: [Screen.Vision.Demo.mp4](https://screen.vision/demo)
- **How It Works:**
- Describe your goal (e.g., "Set up 2FA on Google" or "Configure Git SSH keys")
- Share screen via browser’s built-in screen sharing
- AI analyzes screen state using vision language models
- Receive one instruction at a time (e.g., "Click the blue Settings button")
- Automatic progress detection – Next step provided after screen changes