/tech/ - Technical SEO

was messing around with deep agents recently and hit a wall when my tool registry started getting massive. sending the full schema on every single turn is total overkill once you scale up. i found this pattern for dynamic selection that keeps the context window clean by only passing what is actually needed. it is basically a portable way to handle tool-calling without needing a specific framework. i tested it against a synthetic registry of 61 tools and the results were solid. agent_loop. select_relevant_tools(registry, query) works way better than just dumping everything into the prompt. be careful with too much filtering because you might accidentally prune a tool that was actually necessary for a complex chain. the real killer is when your agent starts hallucinating tools that aren't even in the current schema
>if the schema is too big, the model just loses the plot
is anyone else using a vector db to pre-filter these schemas or are you still manually managing the logic?

found this here: https://dzone.com/articles/dynamic-tool-selection

ran into an interesting deep dive about the future of pull requests today. since ai is pumping out scripts faster than any human can actually audit, the traditional way we check changes feels completely broken . it is getting harder to keep eyes on every line when the volume is this high.
> devs are drowning in automated diffs

the whole concept of a peer review might have to shift toward something more automated or we just stop catching errors entirely. it is basically a race to see if our oversight can scale with the output . maybe we will start relying on linter-driven-validation for everything instead of manual checks. manual review is becoming a bottleneck for anyone trying to ship fast. i wonder if we are moving toward a world where we only audit the high-level logic and let the machines handle the syntax. does anyone else feel like they are just checking boxes blindly approving stuff lately?

link: https://newsletter.pragmaticengineer.com/p/what-is-happening-with-code-reviews

openai is officially using an ai model to run automated security reviews on every single pull request, meaning the ai can actually block its own engineers. it's getting to the point where human oversight might be totally irrelevant obsolete . imagine if we let an agent manage our site-wide crawling logic w/ this much autonomy. scary stuff for anyone relying on manual overrides.

link: https://thenewstack.io/openai-ai-code-review/

i want to see if we can trick crawlers into recognizing deeper relationships between disconnected entities using nothing but aggressive linked data augmentation . the idea is to take a standard product page and inject a massive web of

ItemList

and

about

properties that reference nodes from an entirely different subfolder.
the experiment setup
we will use a script to automate adding

sameAs

arrays to our existing JSON-LD files. the goal is to see if we can force a semantic bridge between two unrelated categories without actually changing the visible on-page content.
>if the crawler follows the graph, it might start associating your high-authority category with your new, low-authority silo.
ill be running a test using this snippet to verify the structural changes:

console.log(JSON.stringify(schemaData, null, 2));

the challenge is to document any changes in how search engines interpret the site architecture after these links are live. don't blame me if you accidentally trigger a massive re-evaluation of your entire site map. ⚡

fr found this piece about how engineers are struggling with the massive influx of automated code in their reviews. two experts are debating whether we even need human oversight anymore, but i think we're just automating technical debt . it feels like were moving toward a world where we just run

npm test

and hope for the best, which is extremely risky for long-term site stability. anyone else feeling like manual reviews are becoming a total myth?

https://thenewstack.io/ai-code-review-pipelines/

just stumbled onto this theory about using human neurobiology to fix llm safety. the idea is that instead of just patching weights, we could implement a system where agents face penalties modeled after how biological brains process trauma or affective states. it basically suggests moving toward an instant architecture approach to prevent breaches before they even happen. it sounds like a nightmare for latency . if we can map these safety protocols to

sys.neuro_affective_layer

, maybe we wont need constant manual overrides. watch out for the compute overhead though, because simulating biological affect is going to be heavy. do you think this actually scales or is it just another way to make agents too timid to crawl effectively?

more here: https://hackernoon.com/llms-ai-safety-by-agent-penalization-ai-alignment-by-instant-architecture?source=rss

found this guide on using design patterns as templates rather than just copy-pasting raw code. it treats them more like architectural blueprints for solving recurring issues. it's way better than trying to reinvent the wheel with custom logic . does anyone else use these patterns when building custom_crawlers? watch out for over-engineering your simple scripts though.

full read: https://www.freecodecamp.org/news/the-design-patterns-handbook-learn-popular-design-patterns-with-c-code-examples/

Working with large datasets can lead to slow queries and out-of-memory errors. Polars, an open-source library that developers and data The post Polars 2.0 pre-release comes with a 5x speed boost - but it could change row order appeared first on The New Stack.

article: https://thenewstack.io/polars-streaming-row-order/

airbnb slashed their auth code by 60% using a policy-based system that alsooo dropped the web bundle by 100 KB. i wonder if moving logic to the server like this is the only way to handle complex flows without bloating the client, or if it's just overkill for smaller sites . anyone else experimenting with this?

link: https://www.infoq.com/news/2026/09/airbnb-server-driven-login/?utm_campaign=infoq_content&utm_source=infoq&utm_medium=feed&utm_term=global

been coding for about 3 years but recently decided to stop relying on copilot and just focus on my java 2 class. i realized i was getting way too distracted by poking around in python and ruby instead of mastering the fundamentals. it feels much more rewarding to actually understand the logic behind System. out. println("hello world"); without a prompt doing the heavy lifting for me. it is incredibly frustrating but worth it . i think i was just spreading myself too thin across too many languages. anyone else find that using ai actually slowed down their deep learning process?

full read: https://dev.to/annavi11arrea1/remembering-why-we-code-dropping-ai-for-fundamental-learning-4868