chandrachood

Engineering the future with Generative AI
Prototype → Production
Azure | Google Cloud | SRE
IIM Kozhikode (CPO)

[chandrachood @chandrachood123]

Check out the latest article in my newsletter: AI gives birth to a new virus https://t.co/lka3TreS5F via @LinkedIn

[chandrachood @chandrachood123]

@Dr00n @Telegraph You can host it on your data center when it's open weight

[chandrachood @chandrachood123]

@soham_nayak04 The moment you accept that price it become your price . That makes all the sense

[AI at AMD @AIatAMD]

Calling all devs! Have you joined the AMD AI Developer Program yet? You bring the ideas, we’ll bring the $100 in cloud credits, AMD dev experts, and GPU sweepstakes.

[chandrachood @chandrachood123]

Most people are using AI like a smarter Google.
Top 1% use it like an operating system.

Search gives answers.
Systems create leverage.

Design workflows.
Add memory.
Add guardrails.
Add feedback loops.

That’s when AI stops being impressive and starts being unfair advantage

[chandrachood @chandrachood123]

Most AI builders are playing with prompts.

The top 1% are designing systems.

Prompts are inputs.
Architecture is leverage.
If your AI product breaks when context changes,
you don’t have intelligence.

You have a demo.

[chandrachood @chandrachood123]

@BoringBiz_ Network is absolutely important , Sam Altman , Peter thiel they were connected well ahead the outcome they can bring as well is similar and audacious

[Boring_Business @BoringBiz_]

This 40 minute lecture from Peter Thiel at Stanford will teach you more about business competition than a 2 year MBA program

[chandrachood @chandrachood123]

GPT is the first time in history where your skills scale with what you ask, not just what you know.The next superpower is asking better questions.

[chandrachood @chandrachood123]

@jebuthomas2 @IndianExpress Online coaching , insta and youtube he can try

[chandrachood @chandrachood123]

@IndiaHistorypic Swami Vivekananda , man who brought Indian culture to the West

[FAR.AI @farairesearch]

DeepSeek-R1 crafted a jailbreak for itself that also worked for other AI models.

@sivareddyg: R1 "complies a lot" with dangerous requests directly. When creating jailbreaks: long prompts, high success rate, "chemistry educator" = universal trigger.
👇

[chandrachood @chandrachood123]

@priyaee_ That is hard, the real inmates of America the native Americans are mostly eliminated. Rest are migrants only the timelines and origins changes. If you choose to promote the original Native Americans though they are a minority, it's a welcoming move

[chandrachood @chandrachood123]

Speed is a competitive advantage, often visible in the GenAI race Gemini beat open AI GPT5 they call code red and in days GPT5.2 beats Gemini 3.0 . Being a paranoid helps on the business world may be it's inevitable in GenAI race

[Charly Wargnier ♨️ @DataChaz]

MIT and Oxford just released their $2,500 agentic AI curriculum on GitHub at no cost.

15,000 people already paid for it.

Now it's on GitHub!

It covers patterns, orchestration, memory, coordination, and deployment.
A strong roadmap to production ready systems.

Repo in 🧵 ↓

[chandrachood @chandrachood123]

@CarymaRules That looks like an inferiority complex than other way, he may feel why someone from outside looks good and lives a better life than him. But it can never take to a position of violence. The other person really behaved well and polite even when threatened .

[Avi Chawla @_avichawla]

Fine-tuning LLM Agents without Fine-tuning LLMs!

Imagine improving your AI agent's performance from experience without ever touching the model weights.

It's just like how humans remember past episodes and learn from them.

That's precisely what Memento does.

The core concept:

Instead of updating LLM weights, Memento learns from experiences using memory.

It reframes continual learning as memory-based online reinforcement learning over a memory-augmented MDP.

Think of it as giving your agent a notebook to remember what worked and what didn't!

How does it work?

The system breaks down into two key components:

1️⃣ Case-Based Reasoning (CBR) at work:

Decomposes complex tasks into sub-tasks and retrieves relevant past experiences.

No gradients needed, just smart memory retrieval!

2️⃣ Executor

Executes each subtask using MCP tools and records outcomes in memory for future reference.

Through MCP, the executor can accomplish most real-world tasks & has access to the following tools:

🔍 Web research
📄 Document handling
🐍 Safe Python execution
📊 Data analysis
🎥 Media processing

I found this to be a really good path toward building human-like agents.

👉 Over to you, what are your thoughts?

Find the GitHub repo in the replies!

[Carlos E. Perez @IntuitMachine]

How is it possible that Claude Sonnet 4.5 is able to work for 30 hours to build an app like Slack?! The system prompts have been leaked and Sonnet 4.5's reveals its secret sauce!

Here’s how the prompt enables Sonnet 4.5 to autonomously grind out something Slack/Teams-like—i.e., thousands of lines of code over many hours—without falling apart:

It forces “big code” into durable artifacts. Anything over ~20 lines (or 1500 chars) is required to be emitted as an artifact, and only one artifact per response. That gives the model a persistent, append-only surface to build large apps module-by-module without truncation.

It specifies an iterative “update vs. rewrite” workflow. The model is told exactly when to apply update (small diffs, ≤20 lines/≤5 locations, up to 4 times) versus rewrite (structural change). That lets it evolve a large codebase safely across many cycles—how you get to 11k lines without losing state.

It enforces runtime constraints for long-running UI code. The prompt bans localStorage/sessionStorage, requires in-memory state, and blocks HTML forms in React iframes. That keeps generated chat UIs stable in the sandbox while the model iterates for hours.

It nails the dependency & packaging surface. The environment whitelists artifact types and import rules (single-file HTML, React component artifacts, CDNs), so the model can scaffold full features (auth panes, channels list, message composer) without fighting toolchain drift.

It provides a research cadence for “product-scale” tasks. The prompt defines a Research mode (≥5 up to ~20 tool calls) with an explicit planning → research loop → answer construction recipe, which supports the many information lookups a Slack-like build needs (protocol choices, UI patterns, presence models).

It governs tool use instead of guessing. The “Tool Use Governance” pattern tells the model to investigate with tools rather than assume, reducing dead-ends when selecting frameworks, storage schemas, or deployment options mid-build.

It separates “think” and “do” with mode switching. The Deliberation–Action Split prevents half-baked code sprees: plan (deliberation), then execute (action), user-directed. Over long sessions, this avoids trashing large artifacts and keeps scope disciplined.

It supports long-horizon autonomy via planning/feedback loops. The prompt’s pattern library cites architectures like Voyager (state + tools → propose code → execute → learn) and Generative Agents (memory → reflect → plan). Those loops explain how an LLM can sustain progress across dozens of hours.

It insists on full conversational state in every call. For stateful apps, it requires sending complete history/state each time. That’s crucial for a chat app where UI state, presence, and message history must remain coherent across many generation cycles.

It bakes in error rituals and guardrails. The pattern language’s “Error Ritual” and “Ghost Context Removal” encourage cleaning stale context and retrying with distilled lessons—vital when a big build hits integration errors at hour 12.

It chooses familiar, well-documented stacks. The guidance warns about the “knowledge horizon” and recommends mainstream frameworks (React, Flask, REST) and clean layering (UI vs. API). That drastically improves throughput and correctness for a Slack-like system.

It enables “Claude-in-Claude” style self-orchestration. The artifacts are allowed to call an LLM API from within the running artifact (with fetch), so the model can generate a dev tool that helps itself (e.g., codegen assistant, schema migrator) during the build.

It keeps outputs machine-parseable when needed. Strict JSON-only modes (and examples) let downstream scripts/tests wrap the app and auto-verify modules, enabling unattended iteration over many hours.

Put together, these prompts/patterns create the conditions for scale: a safe sandbox to emit large artifacts, iterative control over code evolution, disciplined research and tool usage, long-horizon memory/plan loops, and pragmatic tech choices. That’s how an LLM can realistically accrete ~10k+ lines for a Slack-style app over a long session without collapsing under its own complexity.

[chandrachood @chandrachood123]

@venom1s A man is bound to protect his sister in law , if she slapped his sister in law she is done

[chandrachood @chandrachood123]

@LucyJayneWhite1 Speaking English on Airport is basic and you have all rights to demand that