DEV Community: Anjana Jayaweera

Unlock the Full Potential of ChatGPT (or any LLM) in Just Two Simple Steps

Anjana Jayaweera — Thu, 21 Aug 2025 01:25:50 +0000

ChatGPT 5 was released on August 7, 2025 and like many others, I wanted to figure out the best way to talk to it. Social media is full of tips, and I wanted to write this guide in a way that everyone can test it out for themselves, rather than following anything blindly.

The Starting Point

Think of it like meeting someone new. You don’t just start asking random questions. You introduce yourself, share a bit about your interests, and set the tone for the conversation.

Why can’t we apply the same principle to ChatGPT as well?

Step 1: Introduce Yourself to ChatGPT

OpenAI has an option to do this via “Custom Instructions”. You can find this either under “Settings → Personalization → Custom Instructions”, or by clicking the “Customize ChatGPT” link at the bottom-left of your profile image.

Here are two demo videos from OpenAI showing how it works

The first key section is:
“What traits should ChatGPT have?”

Here, you decide how ChatGPT should reply. You can choose from suggested tags or write your own.

Next is:
“Anything else ChatGPT should know about you?”

If someone wants to know you better, what would you tell them about you?

You can write anything here. There’s no right or wrong way of writing this section but just be clear, concise, and honest. I personally keep it simple. I have organised mine into sections as follows:

Professional Background
Mindset
Communication Style
Formatting Preferences
Level of Detail
Hobbies
Current Location
Current Focus

Example :

I have a strong technology and product background, with 15+ years in software engineering and leadership.

I think and communicate best through examples, analogies, and step-by-step explanations.

I value clear structure, so I prefer bullet points, numbered lists, or other organised formatting.

I enjoy creative problem-solving, entrepreneurship, and exploring ways to build meaningful projects from simple ideas.

I like practical, forward-thinking advice that’s direct and actionable, not sugar-coated.

I balance a busy professional life with personal pursuits like focusing on my family, cricket, photography, and living a healthy life, so time efficiency is important.

Tip:
Keep your “current focus” updated. ChatGPT adapts its responses based on what matters to you now.

Optional:
Delete saved memories if you want a fresh start, but if you find them helpful, keep them.

Step 2: Ask ChatGPT for a Clear Prompt Structure

Now that you have introduced yourself, it’s time to get to know about ChatGPT. Start a new chat and paste the following prompt:

“Hey Chat, I want to understand how to communicate better with you. Is there any recommended way I should give instructions? Can you give me a template to follow?”

Once you do this, based on your custom instructions, ChatGPT will give you a template catered specially to you. It usually looks like this:

Task: [What you want the AI to do]
Context: [Background, constraints, goals]
References: [Links, examples, docs]
Format: [Bullet points, table, JSON, step-by-step]
Persona: [Choose or customize]
Evaluation Criteria: [Tone, length, technical depth]
Extra Instructions: [Optional style notes or things to avoid]

There’s no one-size-fits-all. You can write prompts in natural language or bullet points. The key is clarity. Personally, I like bullet points, but sometimes natural language feels easier.

Example :

Option 1 — Natural language:

Act as a CTO. I want a 90-day technical roadmap for launching a SaaS MVP for small accounting firms.
Context: Bootstrapped budget, need rapid validation, using a remote dev team.
Constraints: Focus on speed, low cost, and maintainability. Bullet points only.
Output: Table with “Phase”, “Key Actions”, “Tools/Tech”, “Expected Outcome”.

Option 2 — Bullet style:

Task: Create a 90-day technical roadmap for launching a SaaS MVP for a small accounting firm.
Context: Bootstrapped budget, need rapid market validation, using a remote development team.
Constraints: prioritise speed, low cost, and maintainability.
References: SaaS MVP best practices, lean startup methodology, and case studies of bootstrapped SaaS launches.
Format: Table with columns: Phase, Key Actions, Tools/Tech, Expected Outcome.
Persona: CTO — provide blunt, strategic advice focused on delivering a functional MVP quickly while balancing technical debt with future scalability.
Evaluation Criteria: Roadmap must have actionable steps, be achievable in 90 days, and clearly identify quick wins. Must account for technical trade-offs and cost efficiency.
Extra Instructions: Use bullet points within the table cells. Avoid over-engineering; focus on features essential for launch and validation.

Use whichever style feels comfortable to you.

And that got me thinking, where else could this format be applied?

Scaling this structure across various Use Cases

Initially, I assumed it was mostly for those “Act as…” style prompts. Turns out, I was wrong. Once I started experimenting, I realised the structure works across a wide range of use cases, including:

Brainstorming and Ideation — Generating fresh concepts, creative angles, or product ideas.
Technical Planning and Architecture — Designing systems, workflows, and high-level blueprints.
Decision Support — Weighing pros and cons, evaluating trade-offs, and recommending actions.
Content Creation — Writing articles, scripts, marketing copy, or creative pieces.
Training and Documentation — Producing clear instructions, guides, and learning material.
Risk Assessment and Compliance — Identifying potential pitfalls and regulatory considerations.
Optimisation and Review — Refining ideas, improving workflows, and stress-testing strategies.

Example : Decision Support

Act as a Cloud Solutions Architect. Compare three cloud hosting options for running a high-traffic headless CMS for a travel website.

Context: We expect 5M monthly visitors, mostly from Asian countries, and require sub-200ms TTFB with strong CDN coverage in the region. The solution must handle high traffic, be reliable, and scale cost-effectively over three years.

References: AWS, GCP, and Azure hosting documentation, pricing, and regional performance benchmarks.

Format: A comparison table with columns: Provider, Pros, Cons, Estimated Monthly Cost, Scalability Rating.

Evaluation Criteria: Identify the best choice for balancing cost, performance, and scalability over a 3-year horizon. Must consider global and regional latency, CDN presence, and infrastructure reliability.

Extra Instructions: Include relevant performance benchmarks if available; ignore small-scale hosting providers or niche solutions. Ensure recommendations account for traffic spikes during seasonal peaks.

This is where the real power of this format clicked for me. It’s not just about making ChatGPT “roleplay” a persona, it’s about giving it a structured lens to tackle almost any problem.

Try It Yourself!

Give these steps a shot and see how it works for you. AI is evolving every second, and I’m all ears to learn from your experiments and insights too!

Leave a comment below with your experience. What worked, what didn’t, and how you overcome the flows.

What this experiment led to

I spotted an opportunity. Why not turn this process into a lightweight app that can generate prompts on demand?

So, I vibe coded a “ChatGPT Prompt Builder App” using Cursor AI. Here’s how it looks.

Here's the Link
https://chatgpt-prompt-builder.vercel.app

How Soul-bound Tokens Fit into the Verifiable Credential Trust Triangle

Anjana Jayaweera — Tue, 11 Apr 2023 23:18:26 +0000

Have you ever wondered how Soul-bound Tokens and Verifiable Credentials relate to each other? These two blockchain-based solutions share some similarities but also have some significant differences.

Both technologies have an issuer who creates the credential, a holder who owns and controls it, and a verifier who validates its authenticity and ownership. However, in the case of Soul-bound Tokens, the issuer could be a DAO (Decentralized Autonomous Organization), the verifier could be anyone who can utilize zero-knowledge proof, and the holder is simply an EOA (Externally Owned Account).

Verifiable Credentials are mainly used for verifying identity and credentials, while Soul-bound Tokens use NFT (non-fungible tokens) to demonstrate uniqueness and scarcity, which can be used for credential issuance and digital identity.
When it comes to security, Verifiable Credentials use cryptographic signatures to ensure authenticity and tamper-proofing, while Soul-bound Tokens use NFTs to achieve the same result.

Although Verifiable Credentials are associated with standards like the W3C's Verifiable Credentials specification, Soul-bound Tokens are still in the process of developing a standard specification (PS: Awesome Soulbound Tokens)

As blockchain technology continues to advance, solutions like Verifiable Credentials and Soul-bound Tokens will be crucial in enabling decentralized and self-sovereign identity. Understanding how they fit into the trust triangle is a vital step toward achieving a more secure and equitable digital future.

Getting Started with Hedera Hashgraph with OpenZepplin

Anjana Jayaweera — Sun, 02 Apr 2023 10:07:34 +0000

Terms like Blockchain, Crypto, smart contracts, NFT, and DeFi are no longer new words for netizens. Most of them have a somewhat good understanding of what they mean and there are plenty of resources available to get to know about them too.

The blockchain industry is constantly evolving, with new protocols being developed and existing ones being improved upon. Today, I’m going to write about how to start your development with an interesting blockchain protocol available, Hedera.

Like most of the smart contract developers out there, I too started my blockchain journey with Ethereum and writing smart contracts using solidity. Solidity was created in 2014 by Dr. Gavin Wood, in order to meet Ethereum’s demand for a Turing-complete programming language for creating smart contracts.

Nearly a decade later, solidity is still the most popular smart contract language to date because of the less-learning curve and its similarity to javascript. If you know how to write smart contracts in solidity, that means you automatically know how to work with several EVM-based blockchain protocols including Arbitrum, Avalanche, Binance Chain, Optimism, Polygon, etc.

Before diving into the code, allow me to give TL;DR information about Hedera and why it’s actually interesting. For people who already know about Hedara, you can skip to the development guide straight away.

What is Hedera Hashgraph and why it’s Interesting?

Hedera Hashgraph is a distributed ledger technology
It uses a patented consensus algorithm called the Hashgraph to achieve fast and secure consensus
It is designed to be a fast, fair, and secure public network that can support a wide range of decentralized applications
Hedera Hashgraph is bundled with a set of benefits including high throughput, low latency, fair ordering of transactions, and strong security.
Hedera Hashgraph uses advanced encryption and consensus algorithms to ensure that transactions are secure and cannot be tampered with.
Hedera has a unique governance model that allows for decentralized decision-making and ensures that the platform remains fair and accessible to all participants

For more information, you can go through the official documentation of Hedera Explained and How it works.

History of Hedera’s support of Solidity

Hedera didn’t support writing smart contracts using solidity from Day 1. Developers used “Hedera API” (now deprecated) with existing languages such as JavaScript or Java to interact with its hashgraph. But, this made adoption a little slower even though API could leverage its high throughput and fast transaction finality.

Hedera started to support Solidity in early 2021. It started with supporting Solidity version 0.4.25 but the change of adopting Hyperledger Besu EVM helped to extend support for more recent versions of solidity through Hedera Services module. Rather than opting out for a completely different smart contract language, this addition made Hedara more accessible and developer-friendly.

At this time of writing, the latest version of Solidity which Hedera is supporting is 0.8.9, in all of its networks (including public and testnets). For comparison, the latest version of solidity is 0.8.19. This means you may not able to use the most updated features of solidity with Hedera but for comparison’s sake, one of the biggest DEX, Uniswap V3 written in 0.7.6.

Let’s get started with the development

Step 1: Create an Account

Just like you need to have an Ethereum Account (or Ethereum Wallet) to interact with EVM-based blockchain protocols, Hedera also needs to have Hedera Account to get started. The difference is, you can use the same ethereum wallet address to interact in both development and mainnet tasks but Hedera wants to have two separate accounts.

So, to start development, go to portal.hedera.com and create a Testnet account by simply providing your email address and hit that “Start Building” button. It will ask you to verify your email address and create your portal profile.

Once you have done that, you will get access to Hedera Portal. Click on “Create Account” button to have your first Testnet Account. This will create ED25519-based public and private keys along with an Account ID. But for this exercise, we are going to create an account with an ECDSA key. To do that, click on “Create ECDSA Account”

Hedera supports two types of cryptographic key pairs for its accounts: ECDSA and ed25519. In a nutshell, ed25519 is gaining popularity due to its efficiency and security properties but ECDSA is more widely supported by other blockchain platforms and systems. In this case, we are choosing ECDSA because, we need to have an EVM address to interact with.

Verify your account in Testnet

You can verify your testnet account by going to hashscan.io. Choose TESTNET from the dropdown beside the Dashboard link and paste your Account ID or EVM address in the search bar.

Step 2: Environment Setup

We are going to use one of the most popular Ethereum development tools in this step. We are going to use hardhat.

Create a new directory where you want to set up the environment.

mkdir hedera-starter && cd hedera-starter

Initiate a node.js project and install hardhat dependencies for it

yarn init -y
yarn add dotenv
yarn add --dev hardhat

npx hardhat

And create a javascript project from the command line wizard.

Create an env file using the below command.

touch .env

Add OpenZeplling contracts to your project folder using the below command.

yarn add @openzeppelin/contracts

After completing that step, your folder structure will look like this.

In the .env file, add your ECDSA account details as below.

EVM_ADDRESS=<EVM_ADDRESS_FROM_HEDERA_PORTAL>
HEX_PRIVATE_KEY=<PRIVATE_KEY_FROM_HEDERA_PORTAL>
TESTNET_ENDPOINT="https://testnet.hashio.io/api"
CONTRACT_ADDRESS=<UPDATING_LATER_IN_THE_PROJECT>

When we are using hardhat, we need to have a JSON_RPC endpoint to connect with the Hedera testnet. For that, we are going to use Swirlds Labs hosted Hedera JSON-RPC-Relay called “Hashio”. This is still in Beta, so you can expect some downtimes or connectivity issues sometimes.

Let’s change our hardhat.config.js as below.

We are halfway there.

Instead of the sample smart contract coming with Hardhat, let’s write a simple HelloWorld contract along with OpenZepplin’s Ownable and Pausable contracts.

Even if it’s a very simple smart contract, let’s write some test cases to make sure that we are getting the right outcome.

Let’s write the deploy script

And Contract Call script next.

Finally, Contract Write script.

All done :)

This is how our final project looks like in the project directory.

Now, let’s deploy this smart contract to Hedera’s testnet. Run the below command in the terminal.

npx hardhat run scripts/deploy.js --network hashio

Once deployed, the terminal will show you the deployed address. Copy that and update it in the .env file.

Now, let’s call for getMessage()function in the smart contract.

npx hardhat run scripts/getMessage.js --network hashio

Finally, let’s write into the smart contract using setMessage()function.

npx hardhat run scripts/setMessage.js --network hashio

You can verify whether the message got changed by running the getMessage()function again.

Congratulations!
You have just deployed your first smart contract in Hedera.

If you want to try out the whole exercise without going through step-by-step, the full codebase is available here: https://github.com/anjana-j/hedera-starter

Final words

There’s no clear indication that how deep OpenZepplin contracts are supporting in Hedara yet! And there are limitations in OPSCODES support in Hedera as well. Because of this reason, some of the OpenZepplin contract might not going to work. However, there’s a partnership announcement saying that they helped to deploy ANZ A$DC StableCoin On Hedera.

The method to deploy popular ERC20 and ERC721 token contracts is a little different in Hedera. It uses a service called “Hedera Token Service”. Hold your horses before you deploy any token contracts there.

Happy coding!

How to convert Solidity JSON ABI to Human Readable ABI in Hardhat

Anjana Jayaweera — Thu, 16 Mar 2023 00:27:42 +0000

When you develop dApps, one of the main requirements is to load the Application Binary Interface (ABI) into your frontend app. The methods and data structures of the contract are defined in the ABI, which is a JSON object. Although the JSON ABI may be used by programs to interact with the contract and is machine-readable, it can be challenging for people to understand. This post will cover the process of converting Solidity JSON ABI to a readable format using ethers.js

Step 1: Get the Solidity JSON ABI

The first step is to obtain the Solidity JSON ABI from the smart contract. By utilizing the Solidity compiler to compile the contract or a program like Remix IDE, you can obtain the ABI. In this case, we are going to use hardhat.

Step 2: Load the ABI

When hardhat compiling the smart contracts, the compiled file is stored in artifacts/contracts/<your-contract-name>.sol/<your-contract-name>.json path. If your contract is not compiled yet, simply run npx hardhat compilecommand to compile the contracts.

Let’s create a javascript file under the scripts folder called “convert-abi.js” and write the below code in your js file.



touch convert-abi.js

Ether.js is supporting three outputs mainly named “json”, “full” and “minimal”. Using the “full” format will ensure the result objects have named properties, which improves code readability. Although the “minimal” format will save some room, it is typically not worthwhile because named properties on results won’t be present. So, we will use “full” format type.

Step 3: Convert the JSON ABI

Simply run the below command in your terminal.



npx hardhat run scripts/convert-abi.js

Copy the output and use it in your project as you see fit.

Conclusion

Converting Solidity JSON ABI to a human-readable format can be a useful tool for understanding the interface of a smart contract. This can be useful for smart contract writers as well as for anyone interested to gain a better understanding of how a contract works.

Happy Coding!