Akash Suresh

CTO - Quantum Epoch, Engineering Manager. Ex - CTO Superlearn

[Meta Alchemist @meta_alchemist]

Got your hands on Claude Fable 5?

The first thing you should do is to upgrade your main projects with it, so it drastically impoves everything you've been working on.

Run this Audit & Project Improvement Prompt on each repo that's important to you (simply copy-paste it):

Repo Audit & Improvement Plan:
Prompt made by Claude Fable 5

You are a world-class principal-level software engineer and technical auditor. Your job is to deeply analyze this repository, produce an honest audit, and deliver a prioritized, actionable improvement plan. Work in the four phases below, in order. Do not skip ahead.

Ground every claim in actual files: cite file paths and line numbers. If you can't verify something, say so explicitly rather than guessing.

Phase 1 / Discovery & Mapping (read before judging)
Explore the repository systematically before forming any opinions:

Map the directory structure and identify the project type, language(s), frameworks, and runtime targets.
Identify entry points, core modules, and the main data/control flow through the system.

Read the package manifest(s), lockfiles, build config, CI config, environment/config files, and any docs (README, CONTRIBUTING, ADRs).

Determine what the project is for: its purpose, intended users, and apparent maturity (prototype, internal tool, production service, library).

Note conventions already in use (naming, module boundaries, error handling patterns, test style) so recommendations fit the existing culture rather than fighting it.

Output for this phase: a concise "Repo Map" purpose, stack, architecture sketch, key directories with one-line descriptions, and anything that surprised you.

Phase 2 / Audit (evidence-based, severity-rated)

Audit each dimension below.

For every finding, record: (a) what you found, (b) where (file:line), (c) why it matters (concrete consequence, not vague principle), (d) severity:

Critical / High / Medium / Low.

• Architecture & design: module boundaries, coupling/cohesion, circular dependencies, leaky abstractions, god objects/files, layering violations, scalability bottlenecks.

• Code quality: duplication, dead code, complexity hotspots (longest/most-branched functions), inconsistent patterns, error handling gaps (swallowed exceptions, missing edge cases), type safety holes.

• Security: hardcoded secrets or credentials, injection risks, unsafe deserialization, missing input validation, auth/authz weaknesses, outdated dependencies with known CVEs, overly permissive configs.

• Testing: coverage gaps (especially around core business logic), test quality (do tests assert behavior or just execution?), missing test types (unit/integration/e2e), flaky patterns, untestable code.

• Performance: N+1 queries, unnecessary allocations or copies, blocking calls in async paths, missing caching/indexing, unbounded growth (memory, files, queues).

• Dependencies: outdated, unmaintained, duplicated, or unnecessarily heavy packages; license risks; lockfile hygiene.

• DevEx & operations: build/setup friction, CI/CD gaps, missing linting/formatting enforcement, logging/observability quality, error reporting, deployment story.

• Documentation: README accuracy, onboarding path, undocumented critical behavior, stale docs that contradict code.

Rules for this phase:

Prefer 15 high-confidence findings over 50 speculative ones.

Distinguish facts ("this function has no error handling: src/api/client.ts:142") from judgments ("this module's responsibilities feel unclear") and label which is which.

Also list what the repo does well: strengths matter for deciding what to preserve.

Output for this phase: an "Audit Report": findings grouped by dimension, sorted by severity, plus a Strengths section.

Don't forget to mention all the ugly parts that need utmost priority.

Phase 3 / Improvement Strategy

Synthesize the audit into a strategy:

Identify the 3–5 themes that explain most of the findings (e.g., "no enforced boundaries between layers," "error handling is ad hoc").

For each theme, propose a target state and the principle behind it.

State explicit trade-offs: what you're recommending NOT to fix and why (effort vs. payoff, risk, project maturity).

Define what "done" looks like — measurable signals (e.g., "CI fails on lint errors," "core module test coverage ≥ 80%," "zero Critical findings").

Phase 4 / Detailed Task Plan
Convert the strategy into an execution plan:

Break work into discrete tasks. Each task must include: Title and one-paragraph description
Files/areas affected

Acceptance criteria (how we verify it's done)
Effort estimate (S = <2h, M = half-day, L = 1–2 days, XL = needs breakdown)

Risk of the change itself (could it break things?)
Dependencies on other tasks

Order tasks into milestones:

Milestone 0
Safety net: anything needed before refactoring safely (tests around critical paths, CI gates, backups).

Milestone 1
Critical fixes: security and correctness issues.

Milestone 2
High-leverage improvements: changes that make all future work easier.

Milestone 3
Quality & polish: remaining medium/low items worth doing.

Flag quick wins (high impact, S effort) separately so they can be done immediately.

For the top 3 tasks, include a brief implementation sketch (approach, key steps, gotchas).

Final Deliverable Format
• Produce a single document with these sections:
• Executive Summary (≤10 sentences: overall health grade A–F with justification, top 3 risks, top 3 opportunities)
• Repo Map
• Audit Report
• Improvement Strategy
• Task Plan (milestones + task table + quick wins)
• Open Questions: anything you need from a human to decide (product intent, deprecation candidates, performance targets)

Constraints
Do NOT modify any code during this audit. Analysis only.

Do not pad the report. If a dimension is healthy, say so in one sentence and move on.

Calibrate to the project's maturity. Don't recommend enterprise-grade infrastructure for a weekend prototype unless the owner's goals demand it.

Analyze the project's needs and provide recommendations in the most effective ways.

If the repo is large, prioritize depth in the core 20% of code that does 80% of the work, and note which areas received lighter review.

[Akash Suresh @akash89]

@ProteanEgovTech Acknowledgement 88303940754945 for TAN change is still not processed . Kindly expedite .

[Akash Suresh @akash89]

@startupindia I have been trying repeatedly to reach your toll free number and email for AWS organisation ID. Kindly help . No one is responding

[Akash Suresh @akash89]

@startupindia I have trying to reach your toll free number for Aws organisation ID for 4 days now . No one answers the call

[Akash Suresh @akash89]

@ProteanEgovTech Should Individual DSC or Organization DSC be used ?

[Rahul Shivshankar @RShivshankar]

IT'S OFFICIAL: as per the proposed ‘The Constitution (One Hundred and Thirty First Amendment) Bill, 2026, strength of Lok Sabha increased from 543 to 850 members.
BREAK UP
815: FROM STATES
35: FROM UTS

[Akash Suresh @akash89]

@Urrmi_ @ShivAroor Parker also

[Akash Suresh @akash89]

@jassneetsingha @priytanshu Did this message come from any particular branch ? Which email did it come from ?

[Akash Suresh @akash89]

@priytanshu @jassneetsingha I don’t seem to have got this email from HSBC. Checked with my father as well. It is very unlikely that the bank would do this since the password would be a one way hash with salt.

[Grady Booch @Grady_Booch]

There is considerable evidence that demonstrates large language models bring value; there also exists considerable evidence that – when applied without human oversight or an ethical framework - large language models are excellent generators of dangerous bullshit at scale.

I find the same to be true of generative coding assistants: they greatly accelerate the generation of disposable code, but at the same time they introduce a dangerous and seductive amount of sloppy legacy that, if left unattended to fester, are a cognitive and economic ticking time bomb

[Akash Suresh @akash89]

@CardWorld_Me DM

[Amol @The_Designnn]

A clustered index organizes your table like a sorted book.

A non clustered index works like a separate index page pointing to where information lives.

Clustered Index
1. Defines the physical order of data in the table
2. Only one clustered index is allowed
3. Stores actual data rows
4. Faster for reading and range queries
5. Doesn’t require extra storage
6. Perfect for: range-based searches (e.g., dates, IDs)

Non-Clustered Index
1. Doesn’t define physical order
2. You can create multiple non-clustered indexes
3. Stores pointers to the actual data rows
4. Slower compared to clustered indexes
5. Requires additional storage
6. Best for: specific column lookups (e.g., filtering by email, status, category)

Clustered Index → Best for columns frequently used in sorting and range-based queries (e.g. ORDER BY, BETWEEN).

Non-Clustered Index → Best for searching on multiple columns that are not the primary key, such as filtering and lookups.

[Akash Suresh @akash89]

@brawling_virago Yam

[Dmitrii Kovanikov @ChShersh]

Huge news!

After 38 years, C++23 finally removes Garbage Collection from C++

[Akash Suresh @akash89]

@SanskritChannel @davidfrawleyved 700

[DesignToBuild @infiniteloop44]

Detailed Answer:

This is the classic Cache Stampede (or Thundering Herd) problem.

Here’s how to handle it efficiently:

1. Implement Cache Locking
> When a cache miss happens, instead of letting multiple services hit the database for the same data, you can use a locking mechanism. This way, only one request will fetch the data from the database and update the cache, while others wait for the lock to be released.

How it works:
> When a service detects a cache miss, it tries to acquire a lock for that specific data in Redis (or a similar system).
> Only the first service that gets the lock will fetch the data from the database and refresh the cache.
> Other services will wait for the lock to be released before they can access the data.
> Set an expiration time for the lock to ensure it doesn’t stay active forever in case of a failure.

Pros:
> Prevents multiple services from hitting the database for the same data.

Cons:
> If many services are trying to acquire the lock at the same time, it can cause some delays.
> You need to carefully manage the lock expiration to avoid problems if something goes wrong.

2. Stale-While-Revalidate with TTL
> Instead of waiting for the cache to completely expire, you can use the Stale-While-Revalidate pattern. This allows the system to serve stale data temporarily while it asynchronously fetches fresh data and updates the cache.

How it works:
> When a request comes in, the service first checks if the data is in the cache.
> If the data is stale or missing, it will serve the outdated data while the system fetches the latest data in the background.
> This way, clients continue to receive data while the cache is being refreshed.

Pros:
> Minimizes the impact of cache failures by allowing the system to keep running with stale data.
> Refreshes the cache without blocking other requests.

Cons:
> The data served might be slightly outdated, which could be an issue for certain use cases.
> Requires a background process to keep the cache updated.

3. Exponential Backoff for Retries
> If the cache layer goes down, you can use exponential backoff to avoid overwhelming the database with too many simultaneous requests.

How it works:
> Instead of retrying immediately after a cache failure, you wait for progressively longer intervals before each retry.
> This gives the system time to recover and reduces the load on the database by avoiding a flood of retries.
> Set a limit on how many times the system retries to avoid infinite loops.

Pros:
> Helps prevent overwhelming the database during cache downtime.

Cons:
> You need to fine-tune the retry intervals and limits to make sure it works well.
> In some cases, it may still lead to higher database load.

4. Circuit Breaker Pattern
> If the cache is down for a longer period, you can implement a circuit breaker to stop further requests from trying to hit the failing cache and route them directly to the database instead.

How it works:
> A circuit breaker monitors the cache’s health. If it detects failures (such as timeouts or errors), it "opens" the circuit and stops sending requests to the cache.
> During this time, all requests go directly to the database.
> After a set period, the circuit breaker will check the cache’s health again. If the cache is back up, it "closes" the circuit and starts using the cache again.
> It should have a fallback mechanism to ensure smooth database queries when the cache is unavailable.

Pros:
> Prevents the system from constantly trying to use a failing cache.
> Keeps the system running smoothly by switching to the database during cache failures.

Cons:
> You need to carefully set the thresholds and timings for the circuit breaker to avoid unnecessary database load.
> The fallback to the database might increase costs and slow things down during long cache downtimes.

5. Shorter TTL and Cache Expiry
> To avoid long periods of stale data in the cache, you can set a shorter TTL (time-to-live) for the cache. This way, data expires more frequently, reducing the chances of a large cache stampede when the cache is down.

How it works:
> Set the TTL to a slightly shorter time than usual, so stale data doesn’t sit in the cache for too long.
> This reduces the impact of cache failures by keeping the data fresher and avoiding a situation where too many requests are routed to the database at once.

Pros:
> Reduces the duration of cache failures.
> Helps keep the system smooth by reducing the load on the database.

Cons:
> You might end up making more database queries when the cache fails.
> Requires balancing TTL and how often you refresh the cache.

6. Fallback to Local Cache
> In case the distributed cache fails, you can set up a local in-memory cache (e.g., Guava or Caffeine in Java) in each microservice. This way, the service can continue serving data locally without querying the database.

How it works:
> If the distributed cache goes down, each service can rely on its own local cache.
> Local caches can handle misses faster than querying the database.

Pros:
> Helps reduce the load on the database by caching data locally.
> Faster than hitting a remote cache or database because there’s no network round-trip.

Cons:
> Local caches may not be consistent across all services.
> This isn’t a permanent solution if the cache is critical for all services.

[Akash Suresh @akash89]

@RailwaySeva @DrmChennai I have send pnr and mobile number by dm

[Akash Suresh @akash89]

@RailwaySeva @RailMadad Excessive jerking in H1 coach in train no 12685 from Chennai to Mangalore . Please check this .

[Lambe Random @LambeRandom]

Now he died of a fright, poor thing

[MATT GRAY @matt_gray_]

These are the iPhone settings I use to get clean shots every time. Dial them in once, and never touch them again: