Marco Prontera

Core Web Vitals mystery for ya: Why does Google Search Console say my LCP is bad, but every example URL has good LCP? See attached screenshot. I see developers asking: How can this happen? Is GSC wrong? (I'm willing to bet it is not btw!) What can you do about it? First it's important to understand how this report and CrUX measures Core Web Vitals, because once you do, it's more understandable, though still leaves the question as to what you can do about this (we'll get to that). CrUX measures page loads and the Core Web Vitals number is the 75th percentile of those page loads. That's a fancy way of saying: "the score that most of the page views get at least" — where "most" is 75%. Philip Walton covers it more in this video: https://lnkd.in/erHpTJND For an ecommerce site with LOTS of products, you'll have some very popular products (with lots of page views!), and then a long, long tail of many, many less popular pages (with a small number of page views). The issue arises when the long tail adds up to be over 25% of your total page views. The popular ones are more likely to have page-level CrUX data as we only show data when we cross a non-public threshold so you need to be popular enough to have CrUX data. GSC also lists the popular URLs first. They also are the ones you probably SHOULD be concentrating on—they are the ones that get the traffic! But popular pages have another interesting bias: they are often faster! Why? Because they are often cached. In DB caches, in Varnish caches, and especially at CDN edge nodes. Long tail pages are MUCH more likely to require a full page load, skipping all those caches, and so will be slower. This is true even if the pages are built on the same technology and are optimised the exact same way with all the same coding techniques and optimised images...etc. Caches are great! But they can mask slowness that is only seen for "cache misses". Caching should be a "cherry on top" to boost speed, rather than the only reason you have a fast site. One way I like check this is to add a random URL param to a URL (e.g. ?test=1234) and then rerun a Lighthouse test on it changing the value each time. Usually this results in getting an uncached page back. Compare that to a cached page run (by running the normal URL a couple of times). If it is a lot slower then you now understand the difference between your cached and uncached pages and can start thinking of ways to improve the uncached ones. Ideally you get it under 2.5 seconds even without cache, and your (cached) popular pages are simply even faster still! Incidentally, this can also be why ad campaigns (with random UTM params and the like) can also be slower, though you can configure CDNs to ignore these params. Anyway, hopefully that explains WHY Google Search Console can show this confusing, seemingly contradictory results, and why that doesn't mean it's incorrect. Caching isn't the only reason of course, but it's a common one for this scenario.

Is AI really making software engineers 10x more productive? I dove into the latest data, and the reality is nuanced. My latest free write-up covers it: https://lnkd.in/gVtuFQzW ✍ Here's a sneak peek at the key takeaways: - Productivity gains are modest but real: Studies from companies like Google and Microsoft are showing 20-30% productivity improvements, a significant boost but we're not quite seeing the "10x" claims. In my own work, I see a 10-30% gain on legacy codebases but higher on prototypes. - Developer sentiment is mixed: While (up to) 84% of developers are now using AI tools, trust in their output is declining. A staggering 66% cite debugging "almost correct" AI solutions as their biggest time sink. I've come to rely heavily on checkpoints and rollback features to combat this. - Context is everything: AI excels in greenfield projects and for less experienced developers. However, for senior engineers working on complex, legacy codebases, AI can actually slow them down. This is where I believe we see a difference in what you might hear from start-ups vs. enterprise. - More Code ≠ more productivity: Teams with high AI adoption are merging more pull requests, but this is leading to a 91% increase in review times, creating new bottlenecks. We're seeing more code, but not necessarily faster delivery of value. The bottom line? AI is a powerful situational force multiplier, but it's not a magic bullet. It's augmenting engineering workflows, not replacing engineers. We need to adapt our processes and expectations to leverage these tools effectively. Read the full article to get a data-driven perspective on the current state of AI in software engineering and where we're headed. #ai #programming #softwareengineering

AI can’t think. It just learned to pretend really well. (Apple’s new study proves it) We’ve been sold the story that models like GPT-4, Claude 3, and Gemini are “reasoning”. They’re not. They’re just matching patterns until they break. Let me explain. Most AI reasoning benchmarks are contaminated: The models have likely seen the problems (or their cousins) in training. That’s like testing a student with the answer key in hand. So Apple ran a clean experiment. They picked logic puzzles like Tower of Hanoi and Blocks World. Unseen problems. Simple rules. Adjustable difficulty. The result? • On simple tasks, “thinking” models performed worse than regular ones. • On medium tasks, they looked impressive — but only briefly. • On hard tasks, they collapsed. Completely. Zero correct answers. Worse: The models didn’t even try harder when things got tough. As problems got more complex, they used fewer tokens. They “gave up” before they started. Let that sink in: When real thinking was required, the AI thought less. That’s brick wall. Even when given the exact solution steps — the AI still failed. Not because it couldn’t plan. But because it couldn’t follow basic logic consistently. What does this mean for us? We stop pretending. Today, in 2025, these models aren’t reasoning. They’re simulating it. And that’s fine. As long as we know where the simulation ends. Here’s how to work with the current limits, not against them: 1. Use clean prompts. Avoid fuzzy instructions. Treat the AI like a junior analyst. 2. Give step-by-step scaffolding. Don’t expect it to connect dots across complexity. “Thinking” remains your job. 3. Add your own logic layer. Treat the AI’s output like raw material — not finished thought. 4. Test with unknowns. Use made-up examples to check if it’s thinking or regurgitating. AI is powerful when paired with a clear-thinking human. But left on its own, it’s just autocomplete with confidence. Before you delegate reasoning to your model ask yourself: → Can it solve a new puzzle? → Or is it just replaying the magic trick it learned from the internet? Human thinking remains irreplaceable. Actually, it’s becoming more important than ever. How are you thinking WITH AI? ⬇️ Let me know in the comments. ♻️ Repost to help your network understand how “Reasoning” AI models work. ➡️ Follow Alex Miguel Meyer for more on AI-Empowered Strategy & Leadership.

AI can write a lot of code, but it can't own the outcome. That's why now, the developer's role is more critical than ever. 🧠 Code review has become less about finding syntax errors and more about validating logic, ensuring quality, and thinking critically about the "why" behind the code. The AI can suggest, but the developer will always—and should always—own the merge button. Learn more why your expertise, curiosity, and ownership are your greatest assets in an AI-powered world. 💡 https://lnkd.in/gQkT59pR

✅ 𝐑𝐞𝐚𝐜𝐭 𝐂𝐨𝐧𝐭𝐞𝐱𝐭 𝐈𝐬𝐧’𝐭 𝐆𝐥𝐨𝐛𝐚𝐥 𝐒𝐭𝐚𝐭𝐞 — 𝐔𝐬𝐞 𝐈𝐭 𝐂𝐚𝐫𝐞𝐟𝐮𝐥𝐥𝐲 React Context is one of the most misunderstood features in modern React. Too many teams treat it as a replacement for global state management — and pay the price in performance and complexity. Let's clear this up 👇 🔎 𝐖𝐡𝐚𝐭 𝐂𝐨𝐧𝐭𝐞𝐱𝐭 𝐑𝐞𝐚𝐥𝐥𝐲 𝐈𝐬 Context is best for sharing static or rarely changing values across a tree: ✅ Theme settings ✅ User authentication info ✅ Localization/language It helps avoid prop drilling for deeply nested components. ⚠️ 𝐓𝐡𝐞 𝐏𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞 𝐓𝐫𝐚𝐩 Context updates re-render every consumer. If you store large, frequently-changing state in Context: - Unnecessary re-renders happen everywhere - Components re-render even if they don't use changed data - Your app slows down as it grows ✅ 𝐁𝐞𝐭𝐭𝐞𝐫 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 𝐟𝐨𝐫 𝐃𝐲𝐧𝐚𝐦𝐢𝐜 𝐆𝐥𝐨𝐛𝐚𝐥 𝐒𝐭𝐚𝐭𝐞 For data that changes often, consider: 🔹 Local component state (useState / useReducer) 🔹 Libraries designed for global state, like Zustand, Redux, Jotai These tools can manage subscriptions at a granular level without rerendering your whole app. 𝐑𝐞𝐚𝐜𝐭 𝐂𝐨𝐧𝐭𝐞𝐱𝐭 𝐢𝐬𝐧’𝐭 𝐚 𝐑𝐞𝐝𝐮𝐱 𝐫𝐞𝐩𝐥𝐚𝐜𝐞𝐦𝐞𝐧𝐭. ✅ Use it for static/shared config ✅ Avoid putting dynamic, high-frequency state in Context ✅ Pick the right tool for your state’s shape and needs #React #ReactJS #FrontendDevelopment #WebDevelopment #CleanCode #SoftwareEngineering #StateManagement #ReactTips #DeveloperExperience #JavaScript #Programming #TechLeadership #CodeQuality #FrontendEngineering #UIDevelopment #WebDev #CodeOptimization #ScalableArchitecture #ReactNative #ModernWeb