标签：#webdev

https://preview.redd.it/rbt6z0s1k84h1.jpg?width=1200&format=pjpg&auto=webp&s=87b4980b47fb45994978a1a719b5fbf3180c0860 – 6+ years of shooting, stitching, retouching, design and coding – Built solo. 0 funding, 0 sponsors, 0 ads. – Free for everyone – 80 places online 170 HD 360° panoramas (still only around 30% of what I've shot so far) – Map mode for browsing places across Tasmania, immersive journeys for larger full-screen 360° tours https://tas360.au submitted by /u/vla_dis [link] [留言]

https://lifeappbybabs.netlify.app I want to see if it's worth investing in and buying a domain name submitted by /u/Miserable_Spirit3319 [link] [留言]

TL;DR : Built a RAG pipeline, allows you to upload docs and connect via API/MCP to service. need feedback if you find it useful or confusing: https://rig-rag.vercel.app I got into the whole AI, embeddings, etc workflow for another project of mine and while pretty fascinating how this all ties together, I thought that it is perhaps also useful to others who don’t want to rebuild the whole pipeline from scratch every time. (also, competition seems pretty costly). It is pretty simple: Make account, make memory space, upload your stuff, configure how you want it retrieved, setup scoped API key, connect your AI to the hosted MCP → done. RigRAG lets you: upload / index documents search them via a simple HTTP API or MCP optionally configure retrieval settings like top-k, candidate count, chunking, etc. Currently entirely free to use since I would want to gather feedback first if it's worth pursuing further before I spend too much time into it. I’d really appreciate feedback on it, if something is unclear to setup, should be improved etc. I’m not trying to do a big launch yet so this is more of a “please try it, and tell me what sucks or if its good” thing. Here the link again: https://rig-rag.vercel.app And for the MCP: https://rig-rag.vercel.app/api/mcp submitted by /u/Odysseyan [link] [留言]

submitted by /u/Last_Success5724 [link] [留言]

submitted by /u/Kriem [link] [留言]

Hiring an AI Development Company? Ask These 7 Questions First Most AI projects fail long before deployment. Not because the model is bad. Because teams skip the hard engineering questions. If you're evaluating an AI development company, ask these 7 questions first: 1. How is data secured? AI systems process sensitive business information. Ask: Where is data stored? Is encryption enabled at rest and in transit? Who has access to prompts, logs, and embeddings? Are enterprise security standards followed? Security should be designed in from day one. 2. What observability exists? You can't improve what you can't monitor. A production AI system should include: Request tracing Prompt/version tracking Latency monitoring Cost visibility Error reporting If nobody can explain what happened after a bad output — that's a problem. 3. How do you handle model drift? AI performance changes over time. Questions to ask: How are outputs evaluated? Is feedback collected? How are prompts/versioning managed? What happens when accuracy drops? Production systems need iteration loops. 4. What happens during failure? No system is perfect. Ask: Is there fallback logic? Human review? Retry handling? Graceful degradation? Failure handling matters more than demos. 5. How is access controlled? Enterprise AI systems require permissions. Examples: Role-based access API authentication Audit logs Team-level controls Not everyone should access everything. 6. What compliance assumptions exist? Especially important for regulated industries. Ask whether the system considers: GDPR SOC2 HIPAA Financial or internal compliance rules Compliance cannot be an afterthought. 7. Who owns the infrastructure? Clarify ownership before signing anything. Ask: Who owns the source code? Cloud infrastructure? Models and prompts? Data pipelines? You should avoid vendor lock-in. AI success is rarely about flashy demos. It's about secure infrastructure, reliability, observability, and long-term maintainability. What question

been maintaining a privacy first clipboard manager chrome extension for a while. recently shipped a snippets feature where you type /keyword in any text field and it expands to whatever you saved i use it for: - my product pitch so i dont rewrite it every time - boilerplate comments on github or pr reviews - pasting my product link into discussions - common replies i send over and over it supports two types - rich text with formatting for things like emails, and code with syntax highlighting if you need it. the expansion works through a content script on all websites. comes with a management page where you can search filter by type or language and edit your snippets. everything is saved locally only on your device, currently these are not synced, let's see if user needs the sync facility for these or not. NOTE: currently figuring out how to make this feature work on Google Docs and MS Word submitted by /u/nhrtrix [link] [留言]

Anthropic just announced Claude Opus 4.8 , a major upgrade to their flagship AI model. If you use AI tools to help you write, debug, or architect software, this release has some huge updates that will change your daily workflow. The best part? It is available right now for the exact same price as Opus 4.7. Here is a quick, no-nonsense breakdown of what is new and why you should care. 1. Smarter Coding and "4x Better Honesty" We have all been there: an LLM confidently hands you a block of code, claiming it’s perfect, only for you to find out it breaks completely. Anthropic spent a lot of time fixing this "false confidence" problem. According to their internal testing, Opus 4.8 is four times less likely to let bugs or flaws in its written code pass by unremarked. It has better judgment, meaning it will actually question a bad plan, catch its own mistakes before showing them to you, and admit when it is uncertain about an edge case. 2. Parallel Coding with "Dynamic Workflows" Available in research preview for Claude Code (Enterprise, Team, and Max plans), Dynamic Workflows allows Claude to break a massive programming task down into smaller pieces. Instead of tackling a codebase line-by-line, it can spin up and run hundreds of parallel subagents at the same time to solve large problems. Anthropic notes that it can manage codebase-scale migrations across hundreds of thousands of lines of code from start to merge, verifying everything against your existing test suites. 3. New "Effort Control" Slider You can now manually choose how much processing power Claude puts into a task on Claude.ai and Cowork: High Effort: Claude thinks longer, reasons deeper, and double-checks its work. Best for complex architecture, tricky debugging, or heavy logic. Low Effort: Claude replies much faster and conserves your token rate limits. Best for quick syntax checks, simple explanations, or boilerplate code. 4. Developer API Upgrades If you are building products on top of Claude's API, Amazon

The tech industry is currently in a frenzy. Everyone is rushing to build the next big AI application, slapping a chatbot interface onto a database and calling it a day. But in this gold rush, we are leaving something critical behind: Enterprise Security. Living in a Kali Linux environment and spending time hunting vulnerabilities teaches you one fundamental truth: security is entirely about context. Hardcoded API keys, undocumented access escalations, and compliance blind spots remain the number one cause of major data breaches. Security teams don’t just need a chatbot that can answer questions; they need a single pane of glass. They need a Security Operations Center (SOC). For the Pirates of the Coral-Bean Hackathon (hosted by Coral and WeMakeDevs), I decided to tackle this massive industry problem. Over the course of 4 sleepless nights, I built CoralSec Copilot—an AI-powered, unified Enterprise SOC platform. Here is the complete Captain's Log of my entire journey, the architecture, the roadblocks, and a reproducible guide so you can build and run it yourself. Day 1: The Brainstorm, Grok, and Cursor AI When the hackathon was announced, my initial thought was basic: "I'll build a CLI agent that scans code." I fired up my IDE, opened Cursor, and started bouncing ideas around. I even looked into some AI models like Grok to understand how they process vast amounts of real-time data. But while brainstorming the architecture, I hit a wall. Scanning a GitHub commit for a leaked AWS key is great, but what if the AI also knew whether the developer who pushed that commit had recently escalated their admin privileges? What if it knew the exact SOC2 compliance policy from our company’s Notion workspace? To do this traditionally, I would have to write dozens of messy REST API integrations. I'd have to handle rate limits, write custom Python scripts for GitHub, another set for Slack, another for Notion, and then build fragile ETL (Extract, Transform, Load) pipelines to bring all

Hey everyone, here is a small project I've built over the previous weekend: https://starguessr.vincentwill.com/ I'd love to know what you think :) submitted by /u/Vincenius_ [link] [留言]

Check it out here: broop.id submitted by /u/toplez [link] [留言]

All tests run on an 8-year-old MacBook Air. All results from shipping 7 Mac apps as a solo developer. No sponsored opinion. The most common Tauri v2 frustration: you write a command, invoke it from the frontend, and nothing happens. No error. No crash. Just silence. It's almost always permissions. How Tauri v2 permissions work Tauri v2 introduced a capability system. Every plugin action — reading files, executing shell commands, sending notifications — requires an explicit permission declaration in your config. Without the permission, the plugin call fails silently on the frontend. The Rust code never runs. // src-tauri/capabilities/main.json { "identifier" : "main-capability" , "description" : "Permissions for main window" , "windows" : [ "main" ], "permissions" : [ "core:default" , "fs:read-all" , "fs:write-all" , "shell:allow-execute" , "opener:allow-open" , "global-shortcut:allow-register" , "global-shortcut:allow-unregister" ] } Note: As of Tauri v2.1, shell:allow-open is deprecated. Use tauri-plugin-opener and opener:allow-open instead. The debugging flow When a command does nothing: Open DevTools ( Cmd+Option+I in dev mode) — check the console for a rejected Promise or permission error Check your terminal output — the Rust side logs errors directly in the tauri dev terminal; look for lines like [tauri] permission denied or not allowed Enable verbose logging — set RUST_LOG=tauri=debug before running tauri dev for more detailed backend output Check your capabilities file — missing or misspelled permission identifiers are the #1 cause Permission errors in the console typically look like a rejected Promise with a message such as plugin:shell|execute not allowed . The capabilities file is always the first thing to check. Common permissions you'll need "permissions" : [ "core:default" , "fs:read-all" , // read any file "fs:write-all" , // write any file { "identifier" : "shell:allow-execute" , "allow" : [{ "name" : "my-cmd" , "cmd" : "adb" , "args" : true }] }, "op

I have been a Python developer for two years. I know Flask, basic machine learning, and I have built a few automation scripts. But when a friend asked me to build him a simple mobile app — something clean, with a login screen and a dashboard — I froze. Mobile development felt like an entirely different world. That experience pushed me to explore something I had been ignoring: AI-powered no-code app builders . What I found completely changed how I think about building software. The Problem With Traditional App Development Most developers think in terms of languages and frameworks. Want an Android app? Learn Kotlin. Want iOS? Learn Swift. Want both? Learn Flutter or React Native. The learning curve is real and the time investment is massive — especially for solo developers or small teams trying to ship fast. But here is the thing nobody tells you early enough: the tool is not the product. The problem you solve is the product. AI tools in 2026 have made it possible to separate these two things. You focus on the problem. The AI handles the implementation. What I Actually Used After researching for about a week, I landed on a combination that worked surprisingly well for my use case. FlutterFlow handled the UI. It is a visual builder that outputs real Flutter code — not some locked-in proprietary format. I dragged and dropped my screens, used the built-in AI generation feature to scaffold entire pages from text prompts, and connected everything to Firebase in about four clicks. ChatGPT filled the gaps. Whenever I hit something FlutterFlow could not handle visually, I described what I needed in plain English and got working Dart code back within seconds. No Stack Overflow rabbit holes. No three-hour debugging sessions. Firebase was the backend. Authentication, real-time database, push notifications — all free at my scale, all connected without touching a server. The result? A working Android app in three days. Not a prototype. A real, testable app that I deployed to Googl

You have a pull request open. Tests are failing. Your PM asks you to fix a production bug — right now. You have two choices: Stash your current work, switch branches, fix the bug, switch back, unstash Clone the entire repo again to a separate folder Both are terrible. But there's a third option most developers don't know about. What Are Git Worktrees? A worktree is a linked copy of your repository that lets you check out a different branch in a separate directory — without switching your current working tree. # While working on feature/login, create a worktree for a hotfix git worktree add ../project-hotfix fix/production-crash # Fix the bug in a SEPARATE directory cd ../project-hotfix # ... make changes, commit, push ... cd ../project # You're STILL on feature/login. Nothing stashed, nothing lost. No stashing. No cloning. No context switching overhead. Why This Is a Superpower 1. Parallel Branches Without the Pain # Review a PR without touching your current work git worktree add ../pr-review feature/new-dashboard cd ../pr-review git log --oneline -5 # Check the commits npm test # Run the tests cd ../project git worktree remove ../pr-review 2. Side-by-Side Comparison Want to compare your branch against main? Open them in two editor windows: git worktree add ../project-main main # Now open ../project/ (your branch) and ../project-main/ (main) side by side 3. CI Debugging Without Stopping Everything # Keep working on feature/x while debugging CI on a specific commit git worktree add ../ci-debug 7a3f9e1 cd ../ci-debug npm ci && npm test # ... debug CI failure without touching ../project/ 4. Documentation and README Updates The classic "quick fix while in the middle of something": git worktree add ../docs-update main cd ../docs-update # Edit README, commit, push cd ../project git worktree remove ../docs-update # Back to your feature branch, zero context loss The Workflow That Changed My Life Here's my daily workflow now: # Monday morning: start feature git checkout -b f

All free to use for handsome guys like yourself. https://dev.versiondb.io/ If it sucks, let me know. If it's good, let me know too. I like feedback. All the data loaded into it can be found here: https://github.com/vdbio submitted by /u/Upper-Character-6743 [link] [留言]

Hi r/webdev ! I've been working on this for a year now and I'm happy to have finally achieved my vision - puzzle reels! Play puzzle games the same way you would watch short form videos: swipe up to skip, play if you want. If you're not a fan of doomscrolling, do the dailies instead or play any of the 19 (and counting) games we have. Free, no ads, and unlimited! Made this because I'm surprised I haven't seen anything like this yet, and that we should spend our free time more intentionally and meaningfully. I think puzzles are a great alternative to passively consuming reels. Built with React, TypeScript, Swiper, and Motion. Check out the site: https://puzzle.express Thank you and happy playing! submitted by /u/trancence [link] [留言]

Over the last few weeks I built a website audit tool and ran it on 200+ small business and service websites — dental practices, plumbing companies, landscapers, law firms, real estate agents. Not Fortune 500 pages optimized by dedicated teams. The sites that actually serve local customers. I expected some issues. I did not expect this. Here's the raw data, the patterns I found, and what you can actually do about it. The Scorecard I grade sites across five dimensions on a 0–100 scale. Here are the averages from 200+ audits: Dimension Average Score Worst Score Speed 56 11 SEO 68 29 Mobile usability 61 18 Accessibility 52 8 Security 70 17 SEO and security tend to be passable (automated checks from Google Search Console and automatic SSL help). Speed and accessibility are consistently neglected — probably because the feedback loop is invisible. A slow or inaccessible site loses visitors silently, and the owner never knows why. Finding #1: 67% of Sites Ship >50% Unused CSS This was the single most surprising data point by far. When a browser loads a page, it downloads every byte of CSS, parses it, builds style rules for every selector, and only then paints. If 60% of those rules never get applied (because they target a contact form behind a click, or a mobile menu at 768px+), the browser still processed them. Worst case: a dental practice shipped 287 KB of CSS. Only 31 KB was used on first paint. That's 256 KB of unnecessary render-blocking weight that delayed First Contentful Paint by roughly 1.4 seconds. The fix: If you're using Tailwind, make sure tree-shaking is enabled. If you're writing vanilla CSS, open DevTools > Coverage tab > Reload. Anything over 40% unused is worth addressing. Most bundlers handle this — you just need to turn it on. Finding #2: Average Image Payload Is 1.8 MB — Way Too High Average image payload across all scanned sites: 1.8 MB per page. Only 34% serve WebP or AVIF (modern formats that cut file size by 30-50%). Only 28% serve responsive sizes

How to handle production incidents — a step by step guide for engineers Incident Response Under Pressure When an outage hits, the goal is not to look smart in the moment; it is to restore service safely, keep people informed, and learn enough to prevent the next incident. The best teams follow a calm, repeatable process: prepare, detect and analyze, contain and recover, then review what happened afterward. Stay Calm First The first skill in incident response is emotional control. Panic makes people chase symptoms, jump between theories, and change too many things at once; calm responders slow the pace, stick to facts, and make the next action explicit. A useful rule is to pause long enough to ask: what changed, what is broken, what is the blast radius, and what is the safest next step. A simple reset phrase helps in the room: “Let’s gather signals, form one hypothesis, test it, and reassess.” That keeps the team from arguing about guesses and pushes everyone toward evidence-driven work. Debug Systematically Use a loop instead of improvisation. Start with symptoms, then check recent changes, then form a small set of likely causes, then test one hypothesis at a time, and finally verify recovery before declaring victory. During an outage, useful questions are: What is failing, and what is still working? When did it start? What changed right before it started? Is the problem isolated or widespread? What logs, metrics, traces, or user reports support each theory? Preserve evidence as you go. Avoid restarting systems, wiping logs, or making broad fixes before you understand the failure mode, because that can destroy the clues you need later. Communicate Clearly Stakeholder communication should be planned, not improvised. Good communication identifies who needs updates, what they need to know, how often they need it, and which channel you will use for each group. A practical outage update should cover four things: What happened in plain language. What the user impact is. W

Hello developers, A common issue in team workflows is configuration drift. Staging crashes because of a missing env variable, or a teammate spends hours debugging because they did not get the updated configuration. The typical workaround is sharing env files over chat apps to compare them, which is a major security risk. To solve this, I built envlint. It is an open-source tool written in pure Node.js with zero npm dependencies. How it works: - It creates a schema file (.env.schema) with key names, expected types (string, number, boolean, url, port), and defaults. - The schema contains no secrets and is committed to Git. - Developers run validation locally or in CI/CD. - It includes a diff command to compare keys across environments (e.g. .env and .env.staging). It prints key presence but suppresses all values so that terminal logs remain secure. Technical Details: - Language: JavaScript (Node.js standard library) - Dependencies: Zero - Size: Under 50KB What I learned building this: I spent a lot of time writing a custom parser in JavaScript instead of using regex or third-party parsers like dotenv. Writing a custom parser allowed me to handle edge cases like comments, multiline values, and inline types much more reliably. The project is fully open source under the MIT license: https://github.com/7xmohamed/envlint I would love to hear how you currently manage environment verification in your teams. submitted by /u/7xmohamedd [link] [留言]

Disclosure up front: I maintain one of the five libraries tested (SignalTree), and it's the one that scored worst in the cold run — so this isn't a "look how good my thing is" post. The cross-library pattern and the fix were interesting enough that I wanted to put the numbers in front of people who use Copilot/Cursor/Claude Code every day. The whole harness is reproducible (one command, link at the bottom); I'd rather it get torn apart than taken on faith. Setup Libraries : NgRx (classic), NgRx SignalStore, Akita, Elf, SignalTree. Agents : Claude Sonnet 4.6, GPT-5.4, Gemini 3.1 Pro, Perplexity Sonar Pro, Claude Haiku 4.5, GPT-5.4-mini. 8 prompts : counter, paginated users, debounced search, derived totals, login form, undo/redo, deep nested state, multi-marker editor. 5 libs × 6 agents × 3 priming modes = 720 cells . Temperature 0. Identical prompt text per library (only the library name swapped). Scored on three orthogonal checks: idiomatic-pattern match, import resolution (does every import resolve to a real package), and method validity (do the called methods actually exist on the API). What this measures: one-shot generation. The agent gets the prompt, returns a file, we score it. Real interactive use — Cursor/Copilot with chat back-and-forth, where the model sees its own errors and gets a second try — is a different setting, and the lift could be larger or smaller there. This is the cold-shot case. Finding 1: cold accuracy basically tracks how much the library is in the training data No context provided, just "write this in library X": Library Cold score Akita 94% Elf 94% NgRx (classic) 91% NgRx SignalStore 86% SignalTree 49% The libraries that have been around for years, with thousands of blog posts and Stack Overflow answers, score in the 90s. The youngest/smallest library in the set scores ~49%. That gap isn't really a quality signal — it's a corpus signal. The models have simply seen orders of magnitude more Akita than SignalTree. Worth keeping in mind any