Jetbrains Grazie: AI writing companion for people in tech 🚀

If you spend more time writing documentation, commit messages, blog posts or support tickets than you’d like, JetBrains just launched something you’ll want to try: Grazie.

It’s an AI writing assistant built for people in tech, helping make all those non-code texts better, faster.

🔍 What Does Grazie Do?
• Instant proofreading (grammar, spelling, punctuation, style)
• Inline text completion
• Summarization
• Translation across several languages
• Rephrasing / tone correction / synonymization
• AI-Chat

🛠 Where It Works & Pricing
• Plugin for JetBrains IDEs
• Browser extension for Chromium-based browsers
• Google Docs, Sheets, Gmail
• GitHub
• Slack
• And many more ...


[ Download ] : https://www.jetbrains.com/grazie

〰️〰️〰️〰️〰️〰️
#AI #Jetbrains #GrammarAI
@ProgrammingTip

GitHub MCP Registry: The fastest way to discover MCP Servers 🔝

If you’ve tried connecting AI agents to your development tools, you know the pain: MCP servers scattered across numerous registries, random repos, buried in community threads — making discovery slow and full of friction without a central place to go. Meanwhile, MCP server creators are worn out from publishing to multiple places and answering the same setup questions again and again.

The GitHub MCP Registry launches as your new home base for discovering MCP servers. Whether you’re building with GitHub Copilot, agents, or any AI tool that speaks MCP, this is the place to find what you need. With GitHub already home to most MCP servers, the MCP Registry makes them dramatically easier to discover, explore, and use — helping developers find the right tools faster and contribute to a more open, interoperable ecosystem. ✔️


[ GitHub MCP Registry ] : https://github.com/mcp

〰️〰️〰️〰️〰️〰️
#LLM #AI #MCP #GitHub
@ProgrammingTip

Announcing ChromeDevTools MCP! 🔥

Connect your AI coding agent to Chrome's powerful automation & debugging capabilities with ease.

Key features:

✅ Reliable automation: It can programmatically handle clicks, form fills, dialogs, and page navigation with ease.

✅ Performance insights: Go beyond simple audits. Instruct your agent to record a performance trace and extract actionable insights to optimize your web apps.

✅ Advanced debugging: Empower your AI to analyze network requests, list console messages, take screenshots, and even evaluate scripts in the browser context.

✅ Browser emulation: Easily test different conditions by emulating CPU slowdowns, network throttling, or various screen sizes.

Works well with modern web apps and believe this will unlock new workflows for automated testing, AI-driven debugging, and interactive web development.


[ Blog ] : https://developer.chrome.com/blog/chrome-devtools-mcp

〰️〰️〰️〰️〰️〰️
#AI #LLM #MCP
@ProgrammingTip

Preparing for the .NET 10 GC 🔥

In .NET 9 DATAS (Dynamic Adaptation To Application Sizes) got enabled by default, but .NET 9 is not an LTS release, so for many people they will be getting DATAS for the first time when they upgrade to .NET 10.


What does “application size” mean exactly?
This is the LDS (Live Data Size) from GC’s point of view, meaning that if we did the most aggressive GC possible, this is how much memory your application uses. Another way to look at it is this is your long lived data + whatever inflight data you have when a GC occurs.

The goal for DATAS is that you no longer need to do various configurations to try to achieve a heap size proportional to your application usage. The 2 main cases we target with DATAS are:

1) Bursty workloads running in memory constraint environments. DATAS aims to retract the heap size back when the application doesn’t require as much memory and grow it when the app requires more. This is especially important for apps running in containers with memory limits.

2) Small workloads using Server GC — for example, if someone wants to try out a small asp.net core app to see what the experience is like in .NET, DATAS aims provide a heap size much more inline with what the small app actually needs.


[ Article ] : https://maoni0.medium.com/preparing-for-the-net-10-gc-88718b261ef2

〰️〰️〰️〰️〰️〰️
#dotnet #gc
@ProgrammingTip

Cursor agents can now control their own computers 👾

Cursor introduced cloud agents that can control their own computers (VMs) and build software end-to-end.

Instead of just generating code, agents can now:

✅ Run full dev environments in isolated cloud machines
✅ Test features, fix issues, and validate results
✅ Record videos / screenshots / logs as proof
✅ Create merge-ready PRs automatically

At Cursor, 30% of merged PRs are already created by these autonomous agents.

This changes the developer role:
👉 Less micro-coding, more direction, review, and decision-making.

The long-term vision is “self-driving codebases”:
agents that ship features, manage rollouts, and monitor production. 🚀


[ Read More ] : https://cursor.com/blog/agent-computer-use

〰️〰️〰️〰️〰️〰️
#AI #Cursor
@ProgrammingTip

GitHub moved the Copilot runtime to Rust 🚀

GitHub migrated the runtime behind Copilot to Rust, and used Copilot during the migration itself.

✅ Why this is worth reading:

• Runtime work is systems work: a language migration means tracing real production behavior, not just translating syntax.

• Copilot was part of the workflow: useful for exploring an unfamiliar codebase, drafting changes, and keeping momentum through repetitive conversion work.

• The output still needs engineering judgment: boundaries, performance, correctness, and rollout safety are not autocomplete problems.


This is a practical case study for teams asking where coding agents help on a large refactor. Use them to accelerate investigation and implementation. Keep humans on architecture, tests, and production checks.


[ Blog ] :
https://github.blog/ai-and-ml/generative-ai/migrating-the-github-copilot-runtime-to-rust-using-copilot

〰️〰️〰️〰️〰️〰️
#AI #GitHub #Rust #Copilot
@ProgrammingTip

Cloudflare saved 100 TB of RAM with math and Rust 🔥

Cloudflare reclaimed more than 100 TB of RAM globally in a Pingora-based consistent-hashing service. No new hardware. The win came from changing data representation and the algorithms around it.


✅ Lessons:

• Measure retained memory, not only allocation rate.
• Check collection shape: duplicated keys, oversized buckets, and pointer-heavy graphs add up fast.
• Fix the model first: a smaller or more compact structure usually beats micro-optimizing a hot loop.

For high-cardinality caches, routing tables, or tenant maps, take a heap dump before reaching for another cache node. A few bytes per entry becomes expensive at fleet scale.

[ Blog ] :
https://blog.cloudflare.com/saving-100-tb-of-ram-with-math

〰️〰️〰️〰️〰️〰️
#Performance #Memory #Rust
@ProgrammingTip