
Web Developerπ©π»βπ» | Technical Writer | JavaScript | React | Figma | Content Writer @softaims_ | DM for Collaborations
Remote
Joined July 2021
- Tweets9.8K
- Following432
- Followers13.9K
- Likes35.8K
Ishrat retweeted
Commonly Used Tech Stacks for Web Development π
Frontend:
β’ HTML5
β’ CSS3
β’ Tailwind CSS
β’ Bootstrap
β’ JavaScript
β’ TypeScript
Frameworks & Libraries:
β’ React.js
β’ Next.js
β’ Remix
β’ Angular
β’ Vue.js
β’ jQuery
Backend:
β’ Node.js
β’ Express.js
β’ Python
β’ Django
β’ PHP
β’ Laravel
β’ Ruby on Rails
Databases:
β’ PostgreSQL
β’ MySQL
β’ MongoDB
β’ Redis
β’ Firebase
β’ Supabase
Developer Tools & Deployment:
β’ VS Code
β’ Git & GitHub
β’ Docker
β’ AWS
β’ Vercel
β’ Netlify
β’ Postman
Web Design:
β’ Figma
β’ Photoshop
β’ Illustrator
β’ Canva
What other tools or technologies would you add to this list?
Ishrat retweeted
Building a side project but don't want to manage a database?
Try these:
1/ Supabase - PostgreSQL + APIs
2/ Neon - Serverless PostgreSQL
3/ MongoDB Atlas - Cloud MongoDB
4/ Turso - SQLite-based database
5/ Firebase - Firestore database
All offer free tiers for getting started.
Ishrat retweeted
Replit was rejected by Y Combinator 3 times in a row.
They were told: "This isnβt a startup, itβs just a fun toy."
A browser where anyone could write and run code? Cute. Not a business.
Amjad Masad and Haya Odeh kept building anyway.
Fast forward to today:
- 60M+ users worldwide
- $400M raised at a $9B valuation earlier this year
- YC itself is now an investor
The "FUN TOY" turned out to be the thing that made coding accessible to people who never thought they could build software. Now itβs one of the platforms behind the shift that lets anyone take a product from idea to working app.
A few lessons we can take from this:
Rejection is data, not a verdict.
Three "NO"s didnβt mean the idea was wrong. It meant they werenβt ready to see it yet.
"TOY" is often what people call something thatβs early. Plenty of world-changing products looked like toys at first.
Consistency compounds. Years of shipping while people doubted you can turn into an overnight success.
Keep going. Never stop building π€
Ishrat retweeted
Okayy deployed it today, come try it free! π₯
I built this primarily for my bullet journaling, but can be used to write anything.
It's completely local, whatever you write stays with you.
Live site: alicalimli.com/shiruya
Ishrat retweeted
The this keyword is one of those JavaScript concepts that looks simple but often causes confusion.
At its core, this refers to the context in which a function is called.
The important part is:
this is determined by how a function is called, not where it is defined.
Here are the common cases:
1. Inside an object method
const user = {
name: "Ishrat",
greet() {
console.log(this.name);
}
};
user.greet(); // Ishrat
Here, this refers to the user object.
2. Inside a regular function
In non-strict mode, this can refer to the global object.
In strict mode:
"use strict";
function greet() {
console.log(this);
}
greet(); // undefined
3. Inside an event handler
button.addEventListener("click", function () {
console.log(this);
});
Here, this refers to the element that triggered the event.
4. Arrow functions are different
Arrow functions don't have their own this.
They inherit this from their surrounding scope.
const user = {
name: "Ishrat",
greet: () => {
console.log(this.name);
}
};
user.greet(); // undefined
This is one reason you should be careful when using arrow functions as object methods.
The key takeaway
Don't memorize "this always means the current object."
Instead, ask:
"How was this function called?"
That usually tells you what this refers to.
Understanding this makes objects, event handlers, classes, callbacks, and frameworks like React much easier to reason about.
Ishrat retweeted
What is Fine-tuning? π
Fine-tuning is the process of continuing to train a pre-trained model on a new dataset.
Instead of simply providing the model with additional context like RAG,
you're updating the model's learned parameters.
In other words :
β RAG changes the context.
β Fine-tuning changes the model.
β¨ What does fine-tuning actually change?
A model contains millions or even billions of learned parameters from its original training.
Fine-tuning updates some (or all) of those parameters using your own dataset.
The goal isn't to add documents.
It's to change how the model behaves.
β¨ When should you use fine-tuning?
Fine-tuning is useful when you want the model to consistently :
β Follow a specific writing style
β Produce outputs in a particular format
β Learn a domain-specific task
β Improve performance on a repeated workflow
Think of it as teaching the model a new behavior, not giving it new documents.
β¨ When should you use RAG instead?
If your goal is to work with :
β Company documentation
β PDFs
β Knowledge bases
β Wikis
β Frequently changing information
RAG is usually the better choice.
The documents stay outside the model and are retrieved only when needed.
The important thing to remember :
Fine-tuning doesn't turn the model into a searchable knowledge base.
It teaches the model how to behave, not what documents to remember.
That's why AI products like ChatGPT, Claude, Cursor, GitHub Copilot, Perplexity, and Bug0 generally use RAG for dynamic knowledge and fine-tuning when they need to change the model's behavior or capabilities.
Ishrat retweeted
8 AI skills everyone should learn in 2026:
1. Context Engineering
AI is only as good as the context you give it.
Learn how to provide:
β’ Goals
β’ Examples
β’ Data
β’ Constraints
β’ Output format
Better context = better results.
2. Workflow Automation
Stop doing repetitive work.
Automate workflows like:
Lead β AI research β Email β CRM β Follow-up
Learn tools like:
β’ n8n
β’ Make
β’ Zapier
3. AI-Assisted Coding
You don't need to be a developer.
But you should know how to:
β’ Explain problems
β’ Review AI-generated code
β’ Debug errors
β’ Ship faster
4. RAG & Knowledge Systems
Teach AI to use your own data.
Build:
β’ Internal knowledge bases
β’ Customer support bots
β’ Company assistants
β’ Document search
5. AI Integrations
The real magic starts when AI can use your tools.
Learn:
β’ APIs
β’ Webhooks
β’ MCP
β’ Authentication
Connect AI to Notion, Slack, CRMs, calendars, databases, and more.
6. Multimodal Content Creation
Turn one idea into:
β’ Blog
β’ Thread
β’ Carousel
β’ Video
β’ Image
β’ Podcast
One idea. Multiple formats.
7. AI Agents
Move beyond simple prompts.
Learn how to build AI agents that can:
β’ Plan
β’ Reason
β’ Use tools
β’ Remember context
β’ Complete multi-step tasks
This is where AI is heading.
8. AI Search Visibility
People search on:
β’ Google
β’ ChatGPT
β’ Claude
β’ Gemini
β’ Perplexity
Learn SEO, AEO, and GEO.
Create content that's easy to understand, well-structured, and worth citing.
Don't try to learn everything.
Pick one skill.
Build a real project.
You'll learn more from shipping than watching another AI tutorial.
You don't need to master all 8 today.
Pick one skill.
Build a real project.
Keep improving.
That's how you actually learn AI.
---------------------------
Thanks for reading!
Follow @ishrratumar for deep dives into each of these skills. I'll be covering them one by one in upcoming posts.
Ishrat retweeted
π¨ BREAKING: Claude can now build you an ULTRA-PREMIUM 3D ANIMATED WEBSITE in 60 minutes. For free.
Here are 8 prompts to build your dream website Fast:οΏΌ
Ishrat retweeted
What is RAG ? β¨
RAG stands for Retrieval-Augmented Generation.
It's a technique that allows an AI application to retrieve relevant information before asking the LLM to generate a response.
Instead of relying only on what the LLM learned during training, the application first looks up information from external sources, then includes it in the prompt.
How RAG works? β¨
1. You ask a question.
2. The application searches a knowledge source.
It might retrieve :
β Company documentation
β PDFs
β Wikis
β Database records
β Knowledge bases
β Vector databases
The retrieved information is added to the prompt as additional context.
The LLM generates a response using that information.
Isn't that just context? β¨
Not exactly.
Context is everything the LLM receives before generating a response.
RAG is one technique the application uses to retrieve relevant information and turn it into context.
The LLM doesn't know whether that information came from you or was retrieved automatically.
It simply receives the final context and generates the response.
A simple way to remember it :
π Context = Everything the LLM sees.
π RAG = One way the application builds that context.
As AI applications continue to evolve, RAG has become one of the core building blocks for working with company knowledge, documentation, and constantly changing data.
That's why you'll find it in many modern AI products, including ChatGPT, Claude Code, Cursor, and Bug0.
_____________________
Thanks for reading till the end!π
In tomorrow's post, I will explore more about RAG.
Ishrat retweeted
Where does AI memory actually live? β¨
An AI application is still just a software application.
The LLM is only one component inside it.
Just like traditional applications store user data in databases, AI applications store memory outside the LLM.
π Short-term memory
Short-term memory is used while the AI is working on a task.
It can include :
β Your current conversation
β Files you've uploaded
β The task you're working on
β Temporary task information
Once the task or conversation ends, this memory is usually discarded.
It is often stored in application state or a cache.
πΎ Long-term memory
Long-term memory persists across sessions.
It can store :
β Your preferences
β Ongoing projects
β Important facts you've asked the AI to remember
β Frequently used workflows
This information is retrieved whenever it's relevant to a future conversation.
Depending on the application, this information may be stored in :
β SQL or NoSQL databases
β Vector databases for semantic search
β Knowledge bases
β File systems or cloud storage
When needed, the application retrieves the relevant information and sends it to the LLM as additional context.
Can AI memory change over time?
Yes.
Modern AI systems can :
β Update memories
β Delete outdated information
β Retrieve only what's relevant
β Organize memories by user, project, or task
Some systems even support versioning or branching memories for different workflows.
A common misconception is that every LLM has its own memory.
In reality, products like Claude Code, Bug0, ChatGPT, Cursor and many other AI applications usually maintain a single application-managed memory that's shared across different models.
The key idea is simple :
The LLM does the reasoning.
The application manages the memory.
That's why memory in AI is as much a software engineering problem as it is an AI problem.
Ishrat retweeted
everything is gunna work out in the end
if it hasn't worked out then it is not yet the end
Ishrat retweeted
Most people start AI with models.
I did too.
Then I hit a quieter question that made everything clearer:
How does a computer store what it knows about the world?
Ishrat retweeted
What happens when you die:
They divide up your shit.
They summarize your life in 500-1000 words.
People who knew you less say sorry to people who knew you more.
Everyone eats, drives home, and wakes up the next day and goes to work.
Whatever youβre worried about wonβt be in those 500 words.
You can dare greatly or not at all, but youβre gonna die either way.
Might as well squeeze every motherfucking drop out.
Ishrat retweeted
I built this thing called Clicky.
It's an AI teacher that lives as a buddy next to your cursor.
It can see your screen, talk to you, and even point at stuff, kinda like having a real teacher next to you.
I've been using it the past few days to learn Davinci Resolve, 10/10.

















