Anthropic released Claude Opus 4.7 this week. The benchmarks look strong — better coding performance, dramatically improved vision, more reliable long-running tasks, and a model that now verifies its own outputs before reporting back. On paper, it’s a meaningful upgrade.

But here’s my honest reaction: I’m cautiously interested, not excited.

Let me explain why — and what it reveals about a bigger question in AI-driven software engineering.

The Way I Actually Use Opus

If you’ve read my work before, you know I build AI-driven software engineering workflows. And in that context, I’ve landed on a pattern that works well for me:

Opus handles the thinking. Sonnet handles the doing.

When I’m starting a new feature, I bring Opus in for the hard stuff — brainstorming approaches, stress-testing assumptions, defining the architecture. This is where raw reasoning quality matters most. A bad plan executed perfectly is still a bad outcome, and Opus is genuinely better at catching the flaws before a line of code is written.

Then I hand off to Sonnet for code generation and execution. It’s faster, cheaper, and more than capable of implementing a well-defined plan. The combination works well precisely because each model is doing what it’s best at.

This isn’t just a cost hack. It’s a philosophy: AI models, like human team members, should be deployed where their specific strengths create the most leverage.

So Why Am I Not Just Upgrading?

Because Opus 4.7 uses more tokens than Opus 4.6.

Anthropic is transparent about this — the new tokenizer and increased reasoning at higher effort levels mean the same input can map to roughly 1.0–1.35× more tokens. Their internal evals suggest the net efficiency is still favourable. Maybe it is. But “maybe” isn’t good enough when you’re running Opus on your most expensive, most critical tasks.

Opus has always required intentionality. You can’t just point it at everything and hope for the best — you’ll exhaust your token budget fast. The whole reason my Opus-Sonnet workflow exists is because I learned that lesson the hard way. If 4.7 compounds that constraint without delivering a proportional improvement in output quality, the calculus doesn’t change — it gets worse.

To be clear: I haven’t tested it enough yet to make a final call. And some of what I’m reading from early testers — particularly around long-horizon agentic tasks and self-verification — is genuinely compelling. But I’d encourage anyone evaluating this upgrade to resist the benchmark hype and measure what matters to them: cost per useful outcome, not raw capability scores.

The Bigger Picture I’m Watching

Opus 4.7 is one release. The more interesting question it surfaces is: where is all of this actually going?

Here’s what I think: the next frontier in AI-driven software engineering isn’t more powerful individual models — it’s smarter orchestration between them.

We’re moving from “which model should I use?” to “how do I build a system where the right model handles the right task, automatically?” The teams winning at this right now aren’t the ones with the biggest models — they’re the ones with the best routing logic, the best context management, and the clearest understanding of where AI adds leverage versus where it burns budget.

Opus 4.7’s new xhigh effort level and task budgets (now in public beta) are a step in that direction — giving developers more control over how much the model reasons on hard problems. That kind of fine-grained control is going to matter a lot as workflows get more complex.

The models will keep improving. That’s almost guaranteed. The question is whether your workflows are built to take advantage of that — or whether you’re still treating AI as a single, monolithic tool you point at problems and hope for the best.

What I’ll Be Watching

Over the next few weeks I’ll be running Opus 4.7 on my actual planning and architecture tasks — the ones where Opus earns its keep. I’ll share what I find.

If you’re doing similar things, I’d genuinely love to hear how you’re approaching the cost-quality tradeoff. Hit reply and let me know.

Until next time.

While this is true, it also requires to build and maintain the infrastructure around it, which not only adds the costs for the server, but also managing it (specially if you self-host it). Even if you don’t self host it and use a product like AWS Elasticache, the cost can be a burden, specially when you are bootstrapping everything and just starting out, where every penny matters.

I found myself in the same situation when I was working on a side project and I had to use a cache, but I didn’t want to pay for a server or ElastiCache.

I was already using Supabase Cloud’s free version for this project, so I thought of using Supabase only for this purpose. If you have used Supabase before, you’d know that the free limits apply to an organisation and not the account. This meant that I could create a new organisation and maintain upto 500MBs of cache for free in Supabase cloud itself.

Let’s understand the main problem statement - I am using the external API for Reddit to fetch the list of subreddit names from a given keyword. The issue is that this API takes roughly 3-4 seconds for the results, and I don’t want my users to wait for that long, specially for each unique request.

Assumption: Assuming that the subreddit list wouldn’t change or have a significant difference at least for a week, I can cache the results for keywords the users have already searched for, for 1 week.

So here’s how I handled it - for every unique request, I follow this approach:

1. I maintain a config table in the main database, which stores the location, schema name and expiry of that cache schema.

   1. If the config entry doesn’t exist, it means the cache schema also doesn’t exist, so I create a new schema with a predefined name and add entry to config table with expiry of T+7 Days.

   2. If the config entry exists, then I need to check if it’s expiring today. If it’s expiring, then the cache schema needs to be destroyed and recreated again.

   3. As a part of the schema creation or replacement, I also create a predefined set of tables which will act as my cache tables.
      

2. I then query the “subreddit_list” table in the cache schema for the keyword given by the user.

   1. If EXISTS, then I simply return the entries from the cache

   2. If DOES NOT EXIST, then I query the reddit API, get results and save it in the cache.

Here’s a visual representation of how it looks (the dotted lines mean they run as non-blocking background tasks):

Now, everything runs on AWS Lambda and I use Supabase to manage my databases and saving the money I would have had to spend on AWS Elasticache for cache.

Would be happy to hear your thoughts on this! I am open to hearing better alternatives to this approach, if any.

Well, I'm here just to help you through that. Databases and SQL is one of the most crucial concepts in my opinion - which you will use for the rest of your professional life in case you decide to pursue your career in data related roles, and while everyone wants to eventually start with the practical stuff, it's equally crucial to understand how it works in theory, not only because it will help you in interviews, but this will help you understand your everyday work better and solve problems by understanding the concepts at core. So, without wasting more of your precious time, I'll jump right into it.

What is a database?

To keep the language simple, imagine a big container filled with smaller boxes or containers of varying sizes, which may also be linked to one another through some properties or attributes. These boxes have the ability to store a ton of information inside them and helps to organise information better according to the users' needs.

In the diagram 1 - You can see 15 tables from A-O inside a larger container. While these tables have their own storage, they also have the ability to be linked to each through their primary identifying attributes.

For example - Let's assume that Table A is used to store a list of customers for an e-commerce store and holds information such as their name, email address and phone number and Table B stores the list of orders for all the customers and stores information such as which customer placed the order, for how much amount and for what products. Assuming the engineer configured the table in such a way that the primary attribute which uniquely identifies a customer in Table A is the phone number (This will be called the "Primary Key" for Table A), in order to link Table A to Table B, the engineer would also create a "Foreign Key" in Table B which acts as the link between Table A and Table B. The Foreign Key holds the same value as it would in the Primary Key in Table A - so, Table B would hold the phone number of the customer who placed the order as a Foreign Key. You can visualise it better through Diagram 2.

Just to be transparent, attributes such as phone numbers, even though unique, may not be used as a primary key by most companies, the reason being that such fields are usually a part of PII (Personally Identifiable Information) information which is usually a sensitive set of data which most companies protect even from their internal employees and is shared only with those who absolutely need to work with or on the basis of PII information with certain policies in place which protect that set of information.

So what do companies use in place of PII information to create Primary Keys? They use simple integers or an alphanumeric IDs (commonly known as UUIDs) to create a unique identification as a primary key for each table. These keys are then used as foreign keys in subsequent tables which need to be linked together. So the tables in Diagram 2 would probably look a little different in the real world - as shown in Diagram 3.

ACID Properties

Now that you've some understanding of how databases look like in general - there are some rules / properties which need to be kept in mind while creating or working with databases - also commonly known as A.C.I.D. properties.

A - Atomicity

The idea behind atomicity is to maintain the integrity of a transaction. A transaction in databases can be a simple write transaction to your database, for example, you work for a company which provides a digital wallet to it's customers to use for faster and smoother payments, for them a simple transaction could be one customer paying to another customer paying some amount of money.

Let's say for that transaction, a customer X wants to send 100 bucks to customer Y through the wallet, then there are two sub transactions taking place in the database for this:

• Transaction 1: Debit 100 from X's wallet

• Transaction 2: Credit 100 from Y's wallet

What happens if transaction 1 succeeds but while transaction 2 is taking place, some error comes up in the system because of which it fails? If atomicity is not taken care, 100 bucks will get deducted from X's wallet by Y will never receive the money, thus leading to a faulty transaction. Therefore, atomicity states that the transaction as a whole will be considered successful if all the sub-transactions are successful, failing which the entire transaction shall be marked as a failure and all the changes, if any, shall be rolled backed to it's original state.

C - Consistency

Consistency can be considered as an extension to Atomicity. It states that after each operation, the database state should stay consistent before and after the transaction. Extending the example given above - considering the Transaction was successful, if 100 bucks from debited from X and credited to Y, the net amount should still be 100 in the system and not change. Consider a scenario where the transaction above failed, and because atomicity was not followed, 100 bucks got debited from the customer's wallet but Y didn't receive them. In terms of the database, the amount is now 100 bucks less because while there was a debit of that money, it never got credited, so the net change in the amount in system is now -100 instead of 0.

I - Isolation

Isolation states that multiple transactions should be able to occur independently and concurrently without waiting for previous transactions to finish while also maintaining the consistency and atomicity.

Continuing the example given in Atomicity, there would definitely be multiple users in the system who would be doing transactions between themselves at the same time, if the transactions are not allowed to be independently driven, each customer will have to wait for the previous transaction to be finished before they can start with their transaction. This poses another problem - Let's say that a customer Z has a total of 200 bucks as their wallet balance and they owe a total of 300 bucks to two different customers, X and Y (150 each).

If customer Z somehow initiates both the transactions one after the other, the system should be able to handle the transactions in a way where the first initiated transaction by the customer Z should make their wallet balance fall to 50 bucks which is insufficient for the second transaction even if the first transaction is still in progress, and should throw an error to the customer for the second transaction.

This is because if these properties are not followed, because when the customer initiated the second transaction at the same time as the first, the wallet balance would still have been the same and the customer would have been able to make two debit transactions of total 300 bucks on a wallet balance of 200 bucks.

D - Durability

Durability states that after each transaction, the updates and modifications and logs shall be stored in a disk so that the data persists even after a system failure. The effects of the transactions should never be lost

Types of Databases

There are broadly two types of databases, Relational Databases and No-SQL (Non SQL) databases.

Relational Databases

These kinds of databases are structured in nature, usually structured in rows and columns. These are the most commonly used kinds of databases in the industry and can handle complex transactions. Once a schema is defined for a table, all records in the table must follow the same schema. If a new attribute/column needs to be added in the table, then the attribute should also be assigned a value (default or by some custom logic) for all the previous records in the table as well.

No-SQL Databases

These kinds of databases are usually non-structured and are better for transactions which are simpler in nature. Every record can have a different schema inside the tables giving more flexibility for adding attributes without needing to add values for historical data.

One key difference between No-SQL and Relational Databases is the volume of data - generally speaking, No-SQL databases are preferred for use cases where the volume of data is very high because of it's unstructured nature and the ability to transform the data structure as per the requirements. On the contrary - use cases where more complex transactions or logics needs to be performed, relational databases are usually the go-to choice.

One example which comes to mind is - E-Commerce related data is usually stored in relational databases however the application and code logs maybe stored in a non-sql database since the volume of logs is high and generally don't require any complex computations.

I have also uploaded a youtube video on this topic which you can watch as well for more detailed explanation

When I chose Commerce in school, it wasn’t because I loved the subjects — it was because I was scared. Scared of scoring less and ending up jobless. Playing it safe seemed like the only way forward.

Fast forward to my B.Com (H) at Delhi University, where I immersed myself in marketing. Internships, activities, projects — I explored every corner of the field. Yet, deep down, something felt off. I was learning, but not fully present.

Influencer marketing followed. For almost two years, I managed campaigns and offline accounts, checking all the right boxes. On paper, things looked great, but during my second role, I felt a quiet nudge — “This isn’t it.”

No performance issues, no big drama. Just the feeling that I wasn’t giving my 100%. Watching data analysts work their magic sparked curiosity. Could I do that? Thanks to the unconditional support of a senior colleague, I dove into Python and SQL, discovering a whole new world. And that was the turning point.

The path wasn’t easy. Coming from a Commerce background meant endless rejections for technical roles. “You’re not qualified for this,” they said. The education system back then didn’t support cross-domain careers, and I felt stuck.

Then luck knocked — a referral through a friend got me a role at an early-stage startup. I led data analytics, often Googling the simplest things while also learning how a tech team functions. The steep learning curve, endless challenges, and incredible mentors pushed me forward.

Today, I’m proud to say I work in a pure software role, and I completed my Masters in Computer Science in 2024.

This journey — from fear-driven choices to embracing a career shift — has been a rollercoaster. And this year, I’m committed to sharing my learnings, insights, and experiences, hoping they might inspire or guide even one person considering a career switch.

If you’ve ever felt stuck in a path you didn’t love, keep following along. The road might be tough, but trust me — it’s worth it.

Have you ever wondered how gambling businesses always stay in business?

What is a Monte Carlo Simulation?

A Monte Carlo Method can be technically defined as a computational algorithm that rely on random sampling. Such a method can be used to solve any probabilistic interpretation. In simpler words, projecting business costs basis random variables, chances of failure for a machine, impact of launching a new product and many more could potentially be solved using the Monte Carlo method.

How do we use this?

Let’s begin with a simpler example, gambling. Whenever we talk about probability, gambling usually comes up as the first example in our head.
But, have you ever wonder why such businesses (Example - Casinos) always stay in profit? Or, why do they offer double, triple, or maybe even 10 times your invested amount as your prize money if you win the game?
Let’s take a look at it.

For this example, we’ll play a game which I’d like to call ‘Double Dice’.
The rules of this game are simple, you have to throw two dice at once, and if you get the same number on both dice, you win.
The casino decides to put a prize money of say 6 times the amount you bid on your turn if you win, and if you lose, you lose your bid amount. If you bid $10 on one roll of dice and you win, you $60, and if you lose, you lose $10. Seems like a pretty good deal, right? Well, if you look at it in terms of probability, you’ll realise that the house (Casino) always has more opportunities to win. So in this case, the total number of possible outcomes of a 2 dice roll are (6*6) = 36 and you only win in the following 6 outcomes:

1. 1,1

2. 2,2

3. 3,3

4. 4,4

5. 5,5

6. 6,6

That is, when both dice have the same number, therefore, the player can win in only 6 out of 36 outcomes.

Let’s build a Monte Carlo Simulation for this scenario.

Building a function which simulates a 3 dice roll

Now that we have simulated the main part of the game, let’s define the variables

1. SIMULATIONS = Number of times we want to simulate the entire game

2. ROLLS_PER_GAME = Number of times we want the player to roll in the entire game

3. BET_AMOUNT = The betting amount for each role

4. WIN_PROBABILITY = An array of probability of wins after each game

5. END_BALANCE = The end wallet balance of the player after each simulation

6. STARTING_BALANCE = The starting wallet balance of the player at the start of each simulation

Initiating a Plot Figure for our Simulations

Now we will begin writing our loops which will help us simulate the game. An outer for loop for running the simulation for the number of times mentioned in the ‘SIMULATIONS’ variable, and an inner while loop to keep recording the outcomes of the each dice roll within each game and adding lines to our plot figure.

Displaying the plot figure after our simulationsplt.show()

After 10,000 simulations, our figure should look similar to this:

Now let’s calculate the average wallet balance for a player after 10,000 simulations:overall_win_probability = sum(WIN_PROBABILITY)/len(WIN_PROBABILITY)overall_end_balance = sum(END_BALANCE)/len(END_BALANCE)print(f"Average win probability after {SIMULATIONS} runs: {overall_win_probability}")print(f"Average ending balance after {SIMULATIONS} runs: {overall_end_balance}")

The above code would give you the following result:Average win probability after 10000 runs: 0.16678711288711615
Average ending balance after 10000 runs: 11676.773

Therefore, on an average, the player would end up earning ~$1600

Now let’s try reducing the prize money for winning, we were assuming 6 times the betting amount for the above simulation, let’s see what happens if we change 6 to 4. The new figure would look something like this:

Average win probability after 10000 runs: 0.16669690309690652
Average ending balance after 10000 runs: 8333.18

Woah! What happened? We see a drastic change in the average ending balance. But, why did that happen? We can clearly see that on the basis of how much payout percentage the casino gives, we can identify what the average outcome would be by the end of night. Therefore, if the casino chooses to give 6 times / 600% of the betting amount as prize money, they would essentially lose money on an average! But, if the casino keeps the prize money at 400%, which is still pretty generous, they would end up staying at top after the night ends.

Pretty interesting, right?

Some other business use cases

We saw how Monte Carlo Methods can help businesses predict the outcome of events with random variables on an average thus helping them make better decisions.

Where else can we use this? There is certainly no limit to one’s imagination when it comes to applications of this method, for exampling, for a marketing manager, Monte Carlo Analysis of CAC (Cost of Acquiring a Customer) through paid marketing with variables such as Cost per lead could tell the business how much they should be paying per lead to stay profitable OR for a sales manager, after a new product is launched, this analysis with variables such as profits and expenses on selling a product in market mixed with it’s demand could help them forecast what factors need to be controlled in order to help them sell more while staying profitable.

Thank you for reading this article! Kindly leave a clap in case you found this interesting. :)

Let’s jump right in!

Steps:
1. Enabling Google Sheets API
2. Creating Service / OAuth Credentials
3. Creating a function in Python to read / write data from / to Google Sheets.
4. Importing the function and using it

Enabling Google Sheets API

Pre-requisites: You should have a personal (yourname@gmail.com) or a company (yourname@yourcompany.com) Google Account

Steps:

• Go to Google Console and login with your Google Account (if not already logged in)

• On the header, create a new project: (Click on the dropdown that says “My First Project” in my case)

• From the dialogue box that opens up, click on “New Project” and give your project a name of your choosing and under location you can either keep it as default (No Organization) or select your organization, if listed.
  Click on Create.

• Google Cloud will automatically create a project for you and once it’s done, select the created project from the same dropdown in the header as done in Step 2.

• After selecting your newly created project, your screen should look something like this:

• In the search bar, search for “Google Sheets API” and click on the first result and click on “Enable” on the screen that follows.

Congratulations! You have successfully enabled the Google Sheets API for your account. Now we’ll set up our credentials so that our Python Script can authenticate and interact with the API.

Creating Service / OAuth Credentials

After the above steps, you should have landed on a page which looks like this:

From the side navigation bar, click on “Credentials” and click on “+ CREATE CREDENTIALS” from the sub-header and select “OAuth client ID”. (We will be setting our credentials up using OAuth because that is what I personally prefer due to an advantage it gives us over Service Account Credentials.)

From the screen that follows, click on “CONFIGURE CONSENT SCREEN”.

If you are setting this up from your company’s Google Account, then click on “Internal”, otherwise click on “External” on the “User Type” section of the OAuth Consent Screen and click on “CREATE”.

You will then be taken to a 4-Step process of configuring your consent screen.

• On the “App Information” page, fill in your “App Name” (It can be a random name since you are not opening up this functionality to any third party user and is entirely internal to your use), your email ID under the “User support email” and the “Developer contact information” field (towards the end of the page) and click on “SAVE AND CONTINUE”. You may leave the remaining fields empty since they are optional.

• On the “SCOPES” page, click on “ADD OR REMOVE SCOPES”. From the page that pops up, search for “Google Sheets API” as shown below and select all the scopes that show up and click on “UPDATE”.

• After clicking on Update in the above screenshot, this page will automatically close and you will see your scopes added on the page. Scroll down to the bottom and click on “SAVE AND CONTINUE”.

• Under Test Users add your email ID as the test user and directly press “SAVE AND CONTINUE”. (This page will not show up if you are on a company account and you chose User Type as Internal on the first page.)

• Scroll down on the Summary page and click on “BACK TO DASHBOARD”

Click on “CREDENTIALS” page on the side navigation bar again and click on “+ CREATE CREDENTIALS” and choose “OAuth Client ID”. Choose the Application Type as “Desktop App” and give it a random name and click on create. You will now a screen similar to below screen:

Download the JSON on your computer, we will be using this later.

Congratulations! Now you have successfully setup credentials to authenticate with your Google Sheets API.

Creating a function in Python to read / write data from / to Google Sheets.

At this point, I am assuming you already have python installed in your system and you are ready to install and use new libraries.

Before we begin writing our script, we require some libraries for our script to utilise. Install the libraries using the following commands: (Open your terminal and run the following commands)# Will upgrade your pip to the latest versionpip install --upgrade pip# Installing gspread library and a third-party library to convert data from gspread to a dataframepip install gspread gspread-dataframe# Installing oauth2client for authenticationpip install oauth2client

Once all the above commands run successfully, you will have downloaded the required libraries in your system.

Let’s jump right in to create functions which will help us read/write data from/to our Google Sheet.

In the code above, “credentials” variables refer to the file path to your client secrets JSON which you downloaded in the previous step and “storage” variables refer to your storage.json file path. (Remember, storage.json should be created as an empty JSON file while running the code for the first time for the code to automatically generate access tokens and store in your storage.json file for the subsequent uses)

The “sheet_name” variable refers to the sheet in your workbook from / to where you want to read / write the data. For example, in your Google Sheet, you have a tab named “Sheet 1”, then “Sheet 1” shall be passed in your as your sheet_name argument.

The “dataframe” variable in the googleSheetWrite function takes in the dataframe which needs to be posted in the given sheet_name.

The “sheet_url” variable takes in the complete URL of the workbook where all this data needs to be written.

The “boolean” variable in the googleSheetWrite function takes in True or False values. If you pass True, then the function will remove all existing data from the sheet and paste your mentioned dataframe in the sheet else it will overwrite only the cells according to the shape of your dataframe.

The “row” and “col” variables take in integer values to mention the Row Number and Column Number from where the dataframe needs to start pasting. For example, if your row = 1 and col = 1, the the data will be pasted from A1, if row = 2 and col = 1, then the data will be pasted from A2, if row =1 and col = 2, then the data will be pasted from B1 and so on.

In the googleSheetRead function, “col” variable refers to an array of column numbers to be read as a dataframe from the given sheet_name and sheet_url.

For example, if you want to read data from columns A,B,C in the sheet,
col = [0,1,2], if you want to read only columns A and C, then,
col = [0,2].

Please note that the googleSheetRead function will also return the empty cells in the sheet as null values. You can drop the null rows using dropna() function of pandas.DataFrame.

Congratulations, now you can easily read / write data from any Google Sheet that is shared with an Editor Access with the Google Account that you generated the credentials from!