Akash Ranjan

@haider1 The backlash on reasoning limits and trust shows users aren't buying it as just a different philosophy.

anthropic and openai had a clear pattern: oAI released a top model, then anthropic quickly followed with something equal to or better but after gpt-5.5 was widely praised, opus 4.7 was met with criticism, mainly because of stricter limits, less trust, and no reasoning-effort control and signs anthropic turning down performance to save compute

Same job, different math because founder risk is now a multiplier, not a discount.

Ineffable Intelligence just raised $1.1B in a seed round. No product. Founded months ago. Mission: 'superintelligence.' Sequoia led it. Nvidia backed it. Valuation: $5.1B. For context - Anthropic's seed in 2021 was $7.3M. This is 150x. At founding. With nothing shipped. Meta paid Ruoming Pang $200M to be an employee. Sequoia paid David Silver $1.1B to stay a founder. Same job. Different math.

@arpit_bhayani Unfair advantage: knowing most people won’t even try.

pro tip: find your unfair advantage.

@srishticodes They are betting on UBI paid by AI tax revenue

Every CEO bragging about replacing their team with Al and encouraging others to do the same, forgot one tiny detail: If 90% of the country is unemployed, who are you selling to? The Al?! You can't run a profitable business in an economy you just destroyed. Or can you ?

@SumitM_X You are ordering by a column not in the DISTINCT. Fix: include created_at in SELECT or use GROUP BY user_id ORDER BY MIN(created_at).

THIS QUERY RETURNS DUPLICATES !!! SELECT DISTINCT user_id FROM orders ORDER BY created_at; WHY ???

@haider1 Haven't switched to using 5.5, really looking forward to seeing all the positive comments about it.

gpt-5.5 is pretty solid so far gives sharp answers, pushes for accuracy, refines ideas well, and is useful for brainstorming it also handles language nuance better, makes fewer mistakes, and works well for agentic coding in codex > set reasoning to high in codex > set reasoning to extended in chatgpt

@bindureddy This is an example of wrong usage, if used in with planning and review at every step , these kinds of issues will not be there

Running loops burning infinite tokens a day leads to extreme brain rot Once AI has generated 10k lines of code, engineers have zero idea of what is going on The bugs multiply, AI debt spins out of control and uptime drops

@SumitM_X Is there practical usage for these concepts?

What is livelock? Two threads are not blocked, but they keep reacting to each other and never make progress. 5 points to remember here: 1. Livelock = threads keep reacting to each other, make no progress 2. Like Lucknow’s "Pehle aap" too polite, no one moves 3. Threads keep retrying → forever yielding 4. Common in: Lock-free code (no blocking, atomic ops) Optimistic concurrency (assume no conflict, retry if fails) 5. Fix: add random backoff, limit retries, or use coordination

@0xlelouch_ Please note that the figures mentioned above reflect a standard, comfortable lifestyle. While I’ve based this on typical living expenses, it’s important to acknowledge that there is no upper limit for more extravagant or discretionary spending

@0xlelouch_ The numbers for tier 1 city is inflated. Actual realistic number should be in the range of 25-50 k . Talking about Bangalore even if I pay alone for a 2 BHK flat total monthly expenses should not go above 50k .

My friend has a ₹88L CTC at a big tech company. Another friend is a remote contractor making around ₹48L per year. On paper: Big tech friend looks much richer. ₹88L vs ₹48L. Almost double compensation. But in the bank? The remote dev is quietly ahead. Here’s the rough math: Big tech ₹88L CTC breakdown: Base salary: ₹42L Annual bonus: ₹8L RSUs / stocks: ₹25L PF / gratuity / insurance / benefits / other CTC components: ₹13L Looks insane on paper. But monthly cash in hand is mostly based on base salary. ₹42L base = ₹3.5L/month gross After tax, PF, deductions, professional tax, etc: Around ₹2.3L to ₹2.5L/month in hand. Now assume Bangalore / Hyderabad / Gurgaon lifestyle: Rent: ₹35k Food: ₹18k Commute / cab / fuel: ₹10k Weekend outings: ₹20k Gym / supplements / subscriptions: ₹8k Shopping / travel / random expenses: ₹25k Family support / EMIs: ₹30k Total monthly spend: ₹1.4L to ₹1.5L easily. Actual monthly savings: ₹80k to ₹1.1L Still very good. But not as crazy as ₹88L CTC sounds. Now remote contractor earning ₹48L: Monthly income: ₹4L With proper tax planning, business expenses, laptop, internet, software tools, coworking, accounting, travel for work, etc, the structure is very different from salary income. Roughly after tax and expenses: ₹3L to ₹3.3L/month can stay in hand. Now assume he is living from a Tier-2 city or with family: Rent: ₹10k Food: ₹12k Commute: ₹3k Gym / supplements: ₹6k Weekend / cafe / small trips: ₹15k Internet / tools / subscriptions: ₹5k Miscellaneous: ₹10k Total monthly spend: ₹60k to ₹65k Actual monthly savings: ₹2.3L to ₹2.7L This is where people get trapped. They compare CTC. They do not compare cashflow. Big tech friend has: Brand value Better resume signal Strong peer group Great learning environment Stability RSUs that can compound over time Future optionality Remote contractor has: Higher monthly liquidity Lower living cost Location freedom More time flexibility Better savings rate Ability to build side projects quietly So this is not a “big tech is bad” post. Big tech can change your career forever. But the lesson is simple: CTC is not wealth. Monthly in-hand is not wealth. Savings rate is wealth. A ₹88L CTC engineer saving ₹90k/month is not automatically ahead of a ₹48L remote contractor saving ₹2.5L/month. Period.

TVK Vijay's disclosed assets of 600 Cr including 100 Cr in FDs tells you something Not that FDs are bad and you should be giving him financial advice, but that FDs are good He has access to financial advisors, knows how to build a portfolio and is unlikely to be finfluenced

@SumitM_X Firing and then Hiring back , Talent rotation, also getting rid of bottom 5%

Whats up with Rippling... Hiring so aggressively in this market..

@haider1 Really awesome Stuffs, excited to use it

@akashbitm787 > workflow speed is completely different now > stuff like backend cleanup, feature branches, small tools, refactors, UI fixes, data scripts, docs, tests i'm mainly talking about practical engineering work

codex with gpt-5.5 is pretty nuts you can have like 12 agents build something in a day that would've taken a month no exaggeration the model is so good it even turns rough prompts into better deliverables now, going back to claude models at work feels like a downgrade

@TheGeorgePu USS Open Source: sunk off the coast of Hangzhou

Meta closing Llama isn't the story. Meta lost the open-source war. To China. The default open model isn't Llama. It's Qwen. The catch-up king isn't Mistral. It's DeepSeek. The model founders use isn't from Menlo Park. It's from Hangzhou. Muse Spark is a closed model. From a company that already lost the open one. The US lost the open-source layer. Nobody's taking it back.

@0xlelouch_ That's a contract mismatch—expected request/response schema, headers, or ordering. Pact or OpenAPI spec testing catches this before production.

You have applied for a Senior QA engineer role. Interviewer: Your unit tests pass, integration tests pass, but production is broken. A customer workflow requires 5 services to work together, and the handoff between services 3 and 4 is wrong. What testing level is missing?

@haider1 Same. It's not just messy; it's stubborn too. You tell it, no recursion, and it still gives you recursion with a comment saying, avoiding recursion. Gemini 3.5 needs a follow style guide flag. Until then, Claude or local models win for clean code.

really hoping google launches gemini 3.5 pro this month because the most disappointing thing about gemini 3.1 for coding is its code style the code it generates is often messy and inconsistent -- and even when i clearly list the mistakes to avoid, it still repeats them and doesn't follow instructions well

@justinskycak Yeah so we should not jump in directly

Never underestimate how much time and effort you can waste by trying to automate a process you do not understand manually.

@srishticodes This simply implies that the next wave isn’t managed it’s built

This is Crazy. CTOs of billion-dollar companies are taking pay cuts and title cuts to become individual contributors at Anthropic. Workday CTO. Instagram CTO. Box CTO. You dot com CTO. Super dot com CTO. All MTS now. These people had 500-person orgs, board seats, and generational comp packages. They gave it up to write code again. Because something at the frontier is worth more than running a billion-dollar engineering org from a calendar. The smartest technical leaders in tech are voting with their careers. That’s a signal no analyst report will ever capture.

@0xlelouch_ Great breakdown. Missing one Go-ism: singleflight for dedupe across workers, and always http.Transport pooling. Also, dead letter queue + manual replay UI saves your on-call

A good system design interview question for Senior Golang Engineer: Design a high-throughput webhook delivery system that can send millions of webhooks reliably to external customers. This looks simple from outside. “Something happens in our system, call the customer’s HTTP endpoint.” But this is exactly where backend engineering becomes interesting because now you need to think about retries, idempotency, timeouts, rate limits, customer endpoint failures, queue lag, ordering, signature verification, backpressure, worker pools, and what happens when one customer’s endpoint is down for 6 hours. I would start by separating webhook creation from webhook delivery. When an event happens, like payment_succeeded, order_created, or user_deleted, the core service should not directly call the customer endpoint. It should only publish a webhook event into a queue and return quickly. Webhook delivery should happen asynchronously through workers. At a high level, the event producer writes the event to a durable store and publishes it to Kafka, SQS, NATS, or another queue. A webhook dispatcher consumes the event, finds which customers have subscribed to that event type, creates delivery jobs, signs the payload, and pushes jobs into customer-specific or priority-based queues. Worker processes then pick those jobs and send HTTP requests to customer endpoints. The most important part here is reliability. External endpoints are not under our control. Some will timeout, some will return 500, some will be slow, some will return invalid TLS errors, and some will be down completely. So webhook delivery should always assume failure. Every delivery attempt should be stored with status like pending, delivered, failed, retrying, or dead. Retries should be controlled. If a customer endpoint returns 500 or times out, we can retry with exponential backoff: after 1 minute, 5 minutes, 15 minutes, 1 hour, then maybe up to 24 hours. But if the endpoint returns 400 because payload is invalid or URL is wrong, retrying blindly does not help. After max attempts, the event should move to a dead letter queue or failed deliveries table so the customer can inspect and manually replay it. Idempotency is also very important. The customer may receive the same webhook more than once because our worker may timeout after their server already processed the request. So every webhook should include a unique event ID and delivery ID. Customers should be told clearly: “Webhooks are at-least-once delivery. Please deduplicate using event_id.” Trying to guarantee exactly-once delivery over HTTP is usually a trap. For Golang specifically, I would design workers using goroutines, context timeouts, bounded concurrency, and worker pools. One common mistake is spawning unlimited goroutines for every webhook. That works in local testing and then destroys production. I would use a bounded worker pool so we can control how many concurrent deliveries happen globally and per customer. Per-customer rate limiting is a must. One customer may allow only 100 requests per second, another may allow 10,000. Also, if one customer endpoint is slow, it should not block delivery for everyone else. So I would isolate customers using queue partitioning or per-customer concurrency limits. In Go, this can be implemented with worker pools, channels, semaphores, and context cancellation. Timeouts should be strict. Every HTTP request should have a reasonable timeout, maybe 3 to 10 seconds depending on the product. The Go http.Client should be reused, not created per request, because connection pooling matters a lot at high throughput. We should configure transport settings properly: max idle connections, max connections per host, TLS handshake timeout, response header timeout, and idle connection timeout. ...