DEV Community: Mukhtar Wani

You’re Using AI Wrong (And It’s Costing You More Than You Think)

Mukhtar Wani — Sun, 09 Aug 2026 19:12:50 +0000

Authors: Muneer Shaik(@smdmuneer) & Mukhtar Wani(@mawani311)

You're Not Bad at Using AI. You're Just Using It Like Everyone Else.
A year ago, I thought AI was a better search engine.

I'd ask a question.

Copy the answer.

Move on.

When the answer was wrong, I'd blame the AI.

When the answer was generic, I'd blame the AI.

When the generated code didn't work, I'd blame the AI.

Eventually, I realized something uncomfortable.

The problem wasn't the AI. It was how I was using it.

Today, millions of people have access to the same AI models. Yet their results couldn't be more different.

Some developers finish in two hours what used to take two days.

Some writers produce articles that sound thoughtful and original.

Some managers create polished presentations in minutes.

And others?

They complain that AI is inaccurate, overrated, or useless.

They're all using the same technology.

So why are the outcomes so different?

Because AI is not a magic machine.

It's an amplifier.

And what it amplifies depends on you.

The Biggest Misconception About AI
People often imagine AI as a genius sitting beside them.

Ask a question.

Receive the perfect answer.

Problem solved.

That's not what AI is.

A better analogy is this:

AI is the smartest intern you've ever hired.

It has read an incredible amount of information.

It works unbelievably fast.

It never gets tired.

But it also has limitations.

It doesn't know your company.

It doesn't understand your customers.

It wasn't in yesterday's meeting.

It can't see your whiteboard.

It doesn't know why your team rejected a design six months ago.

And yet many people expect it to.

That's the first mistake.

Mistake #1: Expecting AI to Read Your Mind
Imagine walking into a restaurant and saying:

"Bring me food."

What happens next?

The waiter starts asking questions.

What do you like?

Any allergies?

How hungry are you?

Vegetarian?

Dessert?

Now compare that with many AI prompts.

"Write me an article."

"Generate code."

"Design a database."

They're just as vague.

Then people wonder why the results feel generic.

AI can't read your mind.

It only sees the information you provide.

The best AI users don't necessarily write longer prompts.

They write clearer prompts.

Instead of asking:

"Explain Kubernetes."

they ask:

"I'm a Java developer who understands Docker but has never used Kubernetes. Explain Pods, Services, and Deployments using a real e-commerce application."

That's a conversation.

Not a command.

Mistake #2: Treating the First Answer Like the Final Answer
One of the biggest differences between beginners and experienced AI users is surprisingly simple.

Beginners stop after the first answer.

Experienced users are just getting started.

Imagine asking a colleague for advice.

Would you really walk away after their first sentence?

Probably not.

You'd ask questions.

"Can you explain that differently?"

"What if the requirements change?"

"What are the trade-offs?"

"What would happen at scale?"

The same applies to AI.

The first answer is rarely the best answer.

It's the first draft of a conversation.

Some of my best ideas didn't come from the original response.

They came after asking:

"Challenge your own recommendation."

That single sentence often reveals assumptions, weaknesses, and better alternatives.

Mistake #3: Confusing Confidence With Correctness
AI has a superpower.

It sounds confident.

Unfortunately...

Confidence and correctness are not the same thing.

Sometimes AI produces brilliant answers.

Sometimes it confidently invents an API that doesn't exist.

Or references a research paper that was never published.

Or writes SQL that works perfectly—until it's executed against a table with fifty million rows.

This isn't a bug.

It's simply a reminder that AI doesn't replace verification.

The people getting the most value from AI don't trust it blindly.

They verify.

Just like they would verify information from a coworker.

Mistake #4: Using AI to Avoid Thinking
This one surprised me.

Many people ask AI questions they should be asking themselves first.

Instead of asking:

"What's the best architecture?"

Pause.

Write down your own answer.

Then ask AI.

Now compare the two.

Suddenly AI becomes a reviewer instead of a replacement.

That's a much more powerful workflow.

Some of the best engineers I know don't use AI to generate solutions.

They use it to criticize their own.

That subtle difference changes everything.

Mistake #5: Forgetting That Context Is Everything
Imagine asking an architect to design a house.

Without mentioning:

the budget
the climate
the family size
the land
local regulations
The architect has no choice but to make assumptions.

AI does exactly the same thing.

Every missing detail becomes an assumption.

Every assumption increases the chance of an answer that doesn't fit your needs.

Context isn't optional.

It's the difference between generic advice and genuinely useful guidance.

Mistake #6: Copying Instead of Learning
This is especially common among developers.

AI writes a function.

The tests pass.

The pull request gets merged.

Weeks later, someone discovers the code is difficult to maintain, insecure, or surprisingly slow.

The issue wasn't that AI wrote the code.

The issue was that nobody truly understood it.

AI should make you faster.

It shouldn't make you less curious.

Every time AI gives you code, ask one more question.

"Why did you choose this approach?"

You'll learn something.

Eventually, you'll begin predicting the AI's answers before it gives them.

That's when real growth starts.

Mistake #7: Thinking Prompt Engineering Is the Goal
For a while, everyone talked about prompt engineering as though it were the ultimate AI skill.

It's important.

But it's not the destination.

Prompting is just communication.

The deeper skill is learning to think clearly.

People who think clearly usually write better prompts.

Because clear prompts come from clear thinking.

Not clever wording.

The People Who Benefit Most From AI
After watching how different professionals use AI, I've noticed something interesting.

The biggest productivity gains don't come from people who know the most prompts.

They come from people who already have strong judgment.

Experienced engineers.

Great writers.

Curious researchers.

Thoughtful managers.

AI doesn't replace their expertise.

It accelerates it.

Someone with poor judgment becomes wrong faster.

Someone with good judgment becomes effective faster.

That's why two people using the exact same AI model can experience completely different results.

A Better Way to Think About AI
Imagine every professional receives the same powerful race car.

Some immediately drive into a wall.

Some drive carefully but never leave second gear.

A few learn every corner of the track.

The car is identical.

The difference is the driver.

AI works the same way.

The model matters.

But not nearly as much as the person using it.

Final Thoughts
The conversation about AI often focuses on what the technology can do.

I think we're asking the wrong question.

A better question is:

What kind of thinker does AI reward?

From what I've seen, it rewards people who are curious enough to ask follow-up questions.

Humble enough to verify answers.

Disciplined enough to provide context.

And experienced enough to know when the AI is probably wrong.

Those are deeply human skills.

Ironically, the more capable AI becomes, the more valuable those skills become too.

So the next time AI gives you a disappointing answer, don't immediately ask:

"Why is AI so bad?"

Instead ask:

"Did I give AI enough to work with?"

That one question has improved my results more than any prompt I've ever written.

The Pros and Cons of AI Writing Software Directly in Binary Code

Mukhtar Wani — Thu, 30 Jul 2026 03:51:47 +0000

Artificial Intelligence has transformed software development by accelerating coding, automating repetitive tasks, and improving developer productivity. Modern AI assistants can generate code in programming languages such as Java, Python, C++, and Go with remarkable accuracy. As AI capabilities continue to evolve, an intriguing question emerges: Should AI bypass high-level programming languages entirely and generate executable binary code directly?
While this concept promises significant performance gains, it also introduces substantial technical, operational, and governance challenges. Understanding both the advantages and disadvantages is essential before considering such a fundamental shift in software engineering.
Advantages of Direct Binary Generation
One of the most compelling benefits is maximum performance optimization. Traditional software development involves several stages—writing source code, compiling, linking, and optimization—before producing executable machine code. An AI capable of generating binary directly could eliminate much of this process, producing instructions specifically optimized for the target processor. Such optimization could improve execution speed, reduce latency, and maximize hardware utilization beyond what conventional compilers typically achieve.
Another advantage is the elimination of unnecessary abstraction layers. High-level languages introduce layers that simplify programming but can also create inefficiencies. Direct binary generation allows AI to translate application logic directly into machine instructions, potentially reducing overhead and producing leaner executables.
AI could also provide hardware-specific optimization at an unprecedented level. Rather than relying on generalized compiler optimizations, AI could tailor binaries for individual processor families, memory architectures, cache behavior, vector instruction sets, and specialized accelerators such as GPUs, TPUs, or AI inference chips. This level of customization could significantly improve computational performance for high-performance computing, scientific simulations, financial modeling, and embedded systems.
Direct binary generation may also produce smaller executable files. Without the need for verbose source code, intermediate object files, or unnecessary runtime libraries, deployment packages could become more compact, reducing storage requirements and improving distribution efficiency for edge devices and IoT platforms.
Finally, binary executables offer a modest degree of security through obscurity. Reverse engineering binary code is considerably more difficult than reading high-level source code, creating an additional barrier against intellectual property theft or casual attackers. Although this should never replace proper cybersecurity practices, it may provide an additional layer of protection.
Challenges and Limitations
Despite these potential benefits, the drawbacks are far more significant.
The greatest concern is the loss of readability and maintainability. Human developers cannot efficiently interpret binary instructions. Without understandable source code, debugging defects, implementing enhancements, performing maintenance, or transferring knowledge between engineering teams would become extraordinarily difficult. Maintainability has long been recognized as one of the most important qualities of enterprise software.
Another major challenge is platform dependency. Binary code generated for one processor architecture cannot execute on another without regeneration. Unlike portable programming languages that compile across multiple operating systems and hardware platforms, binary-only software would require separate AI-generated versions for every supported environment.
Version control systems also become problematic. Tools such as Git are designed to compare human-readable text files, allowing developers to review code changes, merge branches, and trace software history. Binary files cannot be meaningfully diffed, making collaboration, peer review, auditing, and rollback substantially more difficult.
Testing and verification present another obstacle. Validating binary executables requires specialized debugging tools and deep knowledge of machine instructions. Without readable intermediate code, identifying defects or verifying functional correctness becomes significantly more complex, increasing software quality risks.
Regulatory compliance represents an equally important concern. Industries including healthcare, banking, aerospace, automotive, defense, and insurance often require source code reviews during audits, security assessments, and certification processes. Binary-only applications would fail to satisfy many of these governance requirements, limiting their adoption in highly regulated environments.
Furthermore, AI reliability remains a critical issue. Even highly capable AI systems occasionally generate incorrect or unexpected outputs. If AI produces binary directly, engineers lose the ability to inspect the logical implementation before execution. Detecting hidden defects, security vulnerabilities, or unintended behaviors becomes substantially more difficult.
Finally, binary-only development threatens long-term knowledge preservation. Software systems frequently remain operational for decades, with maintenance performed by multiple generations of developers. Human-readable source code serves as permanent documentation of business logic and architectural decisions. Eliminating this artifact would significantly hinder future modernization, migration, and organizational knowledge transfer.

PROS:

Maximum Performance Optimization - Direct binary generation would eliminate compilation overhead, potentially producing highly optimized machine code tailored to specific hardware architectures.
Reduced Abstraction Layers - Bypassing high-level languages and compilers could create a more direct path from human intent to executable code, theoretically reducing errors introduced during compilation.
Hardware-Specific Optimization - AI could generate binary code optimized for specific processors, instruction sets, and memory architectures, surpassing compiler capabilities.
Reduced File Sizes - Binary code is inherently more compact than high-level source code, potentially reducing storage and deployment sizes.
Security through Obscurity - Binary code is harder to reverse-engineer than high-level code, providing some additional security layer. CONS:
Loss of Readability and Maintainability - Binary code is incomprehensible to human developers, making debugging, maintenance, and knowledge transfer nearly impossible.
Platform Dependency - Binary code generated for specific architectures would require regeneration for different platforms, losing the portability benefit of high-level languages.
Version Control Challenges - Binary files are difficult to track in version control systems, complicating collaboration, rollback, and code review processes.
Verification and Testing Complexity - Testing binary code requires low-level debugging tools and assembly language knowledge, making quality assurance significantly more difficult.
Regulatory and Compliance Issues - Many industries require source code inspection for compliance and security audits. Binary-only code would violate these requirements.
AI Reliability Concerns - Without human-readable intermediate code, verifying AI-generated binary for correctness becomes extremely challenging.
Knowledge Preservation - The software industry relies on maintainable source code for knowledge transfer and long-term software preservation.

Conclusion
The history of programming languages reflects a continuous effort to make software more understandable, maintainable, and collaborative. While AI-generated binary code offers theoretical advantages in execution speed, hardware optimization, and deployment efficiency, these benefits are outweighed by the practical realities of modern software engineering.
The most effective path forward is not replacing high-level languages with binary generation, but enhancing the existing development ecosystem. AI should continue generating clean, secure, and maintainable source code while increasingly sophisticated compilers perform low-level optimizations to produce highly efficient machine code. This approach combines AI's productivity with human oversight, preserves software quality, supports compliance requirements, and ensures long-term maintainability.
As AI becomes an indispensable software development partner, its greatest value will lie in augmenting human expertise—not eliminating the transparency and maintainability that have enabled decades of technological innovation. The future of software engineering is therefore best defined by a balanced collaboration between intelligent AI systems, skilled developers, and advanced compiler technologies, delivering applications that are both high-performing and sustainable.
Authors: Mukhtar Wani (@mawani311) & Muneer Shaik(@smdmuneer)

Technologies impacted by Computer Science

Mukhtar Wani — Thu, 30 Jul 2026 03:44:05 +0000

Computer algorithms impact a wide range of products and industries, as they form the backbone of many modern technologies. Here are some categories of products significantly influenced or driven by computer algorithms:

Search Engines
Google, Bing, and Yahoo use algorithms for indexing, ranking, and delivering relevant search results.

Streaming Services
Netflix, Spotify, and YouTube rely on recommendation algorithms to personalize user experiences.

E-Commerce Platforms
Amazon and eBay use algorithms for product recommendations, pricing, and inventory management.

Smartphones and Devices
Algorithms power facial recognition, voice assistants (like Siri and Alexa), and predictive text input.

Search Engines Algorithms for Indexing, Ranking
An algorithm is simply something that takes a series of inputs, conducts a sequence of actions, and then returns outputs. As a reminder from the The Search Query Journey unit, the algorithm evaluates the results for each vertical separately, and then ranks verticals against each other to combine the results.
The Search algorithms takes a series of inputs, such as:
• The user inputted query
• The user location
• The Search configuration to know how to treat each of those intents and any business logic
The Content to map those intents to specific entities in the Yext platform
With these inputs, the algorithm will first break down the query into tokens to determine what exactly to search for. Then it’ll use a multi-algorithm approach based on the type of content you’re searching on to determine the best results for each vertical. This includes the list of entities, any direct answers, and any detected filters. Finally the algorithm ranks verticals against each other.
This unit covers levers that affect the search algorithm that you can configure. For a more in-depth look at how the Search algorithms work, check out the Search Algorithms reference docs.
Tokens
Tokenization is breaking down a query into discrete units - aka, words! Tokens are used to determine the candidates for matching to searchable fields. To derive tokens, we’ll split out individual words based on white space, strip out casing and punctuation, and ignore common words (called ‘stop’ words) that do not add meaning to the query.

For a query like “What are your products?” the token derived here would be ‘products’. A candidate for token matches might be an entity type of ‘Product’.

How Synonyms Impact Tokens
Synonyms allow us to translate the tokens to different variations that mean the same thing. For example, although we might have ‘jobs’ as an entity type in the platform, we might want the same results to show for ‘careers’, ‘positions’, or ‘vacancies’. You’ll learn more in the Synonyms unit.

How Stop Words Impact Tokens
As noted above, to derive tokens, our algorithm will treat “stop words” differently. The Search algorithm has a built-in list of stop words, such as of, the, and in. These words can distract from the important tokens of a query (e.g. “the best bankers in the tri-state area” becomes “best bankers tri-state area” focusing on the entity, the rating, and the location).

Stop words are treated differently depending on which algorithm is used:
Keyword Search - stop words are given a much smaller weight than other words in a query when matching on keyword search fields. This means that while they’re not completely ignored, stop words have a smaller and smaller effect as query length increases. Additionally, since keyword search is entirely based on token matches, stop words are used for token matching (and thus may return results) when no non-stop words are present.
Inferred Filter - stop words can still be matched in filters, but the Search algorithm will not match an inferred filter that only matches stop words. For example, if you have an inferred filter for “Cancer Care” and a stop word for “care”, the query “Cancer Care” will pull this filter. However, if you search for “Urgent Care”, it will not match on this filter.
Semantic Search - stop words can still be matched on fields with semantic search since this algorithm uses a combination of token matching and semantic similarity scoring. In other words, results with stop words may return if they are semantically similar enough to the search query.
Set additional stop words with the additional Stop Words property. Learn more in the Search Config Properties - Top Level reference doc.

How Custom Phrases Impact Tokens
Custom Phrases are multi-word phrases that the algorithm will treat as a single unit when matching results in Search. This can be useful for listing brand-specific phrases that you do not want partially matching with results.

Custom phrases only affect how fields using keyword search, phrase match, or inferred filter are searched because these three algorithms rely on matching keywords between the query and field values. However, if a field is searched using semantic search, the semantic similarity between the query and the field value may return a result that only partially matches with a custom phrase.
For example, a taco shop might add a custom phrase “corn tortilla” to prevent a query for “corn tortilla taco” from returning results like “corn on the cob”, “ tortilla soup”, or “corn salsa”. If this field is searched with semantic search, a query for “corn tortilla” could still return “flour tortilla” – even if “corn tortilla” is added as a custom phrase – because they are semantically similar.

Search Operators
Search operators allow users to control the logic for how tokens are combined when performing keyword search. Operators are case sensitive and typo-intolerant. The four operators available are:
AND between two tokens requires both tokens appear in a searchable field (e.g. “red AND dog”)
OR between two tokens requires either of the tokens appear in a searchable field (e.g. “blue OR cat”)
NOT before a token requires the token does not appear in any searchable field (e.g. “NOT yellow”)
Double quotes around a phrase requires the entire phrase to appear in a searchable field
These operators can be used individually or combined to apply more complex logic to the tokens included in a keyword search. Check out the Search Operators reference doc for more info.

Multi-Algorithm Approach
Within each vertical, we take a multi-algorithm approach with Search depending on the type of content we’re searching through. Different types of content need to be searched differently. We have algorithms for three different types of content: structured data, semi-structured data, and unstructured data. You choose how you want each type of content to be searched on by setting searchable fields in the configuration (you’ll learn more about this in the Searchable and Display Fields unit).

For the full details on each algorithm, check out the Search Algorithms reference doc.

Source:
https://hitchhikers.yext.com/modules/search120-search-config-overview/04-algorithm-overview/
https://hitchhikers.yext.com/docs/search/search-algorithms/

Recommendation Algorithms:
Research on recommender systems algorithms, like other areas of applied machine learning, is largely dominated by efforts to improve the state-of-the-art, typically in terms of accuracy measures. Several recent research works however indicate that the reported improvements over the years sometimes “don’t add up”, and that methods that were published several years ago often outperform the latest models when evaluated independently. Different factors contribute to this phenomenon, including that some researchers probably often only fine-tune their own models but not the baselines.
In this paper, we report the outcomes of an in-depth, systematic, and reproducible comparison of ten collaborative filtering algorithms—covering both traditional and neural models—on several common performance measures on three datasets which are frequently used for evaluation in the recent literature. Our results show that there is no consistent winner across datasets and metrics for the examined top-n recommendation task. Moreover, we find that for none of the accuracy measurements any of the considered neural models led to the best performance. Regarding the performance ranking of algorithms across the measurements, we found that linear models, nearest-neighbor methods, and traditional matrix factorization consistently perform well for the evaluated modest-sized, but commonly-used datasets. Our work shall therefore serve as a guideline for researchers regarding existing baselines to consider in future performance comparisons. Moreover, by providing a set of fine-tuned baseline models for different datasets, we hope that our work helps to establish a common understanding of the state-of-the-art for top-n recommendation tasks.
Recommender Systems, Performance Comparison, Reproducibility

Source:
https://ar5iv.labs.arxiv.org/html/2203.01155

Product Recommendations
The amount of data generated in e-commerce sales has expressively grown in the last few years. Online stores often receive questions about products related to price, guarantee, and shipping price. By reducing time for prompt answering, stores can improve customer satisfaction and sales conversion rate. The recommendation of available alternative products in case of product unavailability intended by the customer plays a key role in sales growth in this context. This article defines and evaluates a technique for product recommendation based on the product’s facts stored in Knowledge Graphs (KGs). Our KG is filled with facts from natural language questions and answers processed from the e-commerce platform. We exemplify our proposal in a real-world solution, using data from online stores processed by GoBots, a leading e-commerce chatbot business in Latin America. Online sellers assessed the results of the recommendations to evaluate their quality.
The convenience of online stores has captured customers’ attention who, a few decades ago, only made face-to-face purchases in commercial establishments. The COVID-19 pandemic has changed customers’ relationships with such online stores because they were one of the few ways to buy products. The virtual stores, called e-commerces, had to adapt to this growing demand. In this context, the guarantee of security and integrity in online sales should be allied to fair prices and deliveries in a reasonable time. These aspects guarantee a better customer experience throughout the buying process. Product recommendation figures as a key strategy to offer a complete service to the final customer. This aims to deliver one or more products that suit the customer’s taste or need. The suggested product should be compatible with the customer’s purchasing behavior or characteristics. An adequate recommendation is an ally when the required product is not in stock or is no longer traded. In this case, a sale compatible with the customer’s needs would please both the customer and the seller. In this scenario, the customer
would not leave without the purchase, and the seller would not miss a sale. The recommendation system functions as an information filtering. In the e-commerce scenario, the aim is to filter products that may be interesting to a given customer (Shao et al., 2021), choosing products when there are many available options (Isinkaye et al., 2015). Amazon, a big player in the e-commerce scenario, increased its sales by 35% after adopting a recommendation system to display specific products to its customers (Lee and Hosanagar, 2014). However, recommending a product is not an easy task. It depends on the recommendation strategy adopted to be successful. Existing approaches use different data sources to identify the compatibility between the customer purchase history and the catalog of items in the ecommerce platforms. Examples of these data are product ratings, attributes, and user search history (Dwivedi et al., 2020). The strategy can vary from collaborative filtering (Linden et al., 2003), machine learning (Covington et al., 2016) and Knowledge graph-based techniques (Guo et al., 2020). Lately, knowledge graphs (KGs) have been studied and explored for recommendation purposes. For example, AliCoco, a KG used in the largest e-commerce in China, AliBaba (Luo et al., 2020). KGs are helpful to represent connections between customers, products, and sales.
Source:
https://www.scitepress.org/PublishedPapers/2022/113883/113883.pdf

Facial Recognition
Face recognition is one of the most active research fields of computer vision and pattern recognition, with many practical and commercial applications including identification, access control, forensics, and human-computer interactions. However, identifying a face in a crowd raises serious questions about individual freedoms and poses ethical issues. Significant methods, algorithms, approaches, and databases have been proposed over recent years to study constrained and unconstrained face recognition. 2D approaches reached some degree of maturity and reported very high rates of recognition. This performance is achieved in controlled environments where the acquisition parameters are controlled, such as lighting, angle of view, and distance between the camera–subject. However, if the ambient conditions (e.g., lighting) or the facial appearance (e.g., pose or facial expression) change, this performance will degrade dramatically. 3D approaches were proposed as an alternative solution to the problems mentioned above. The advantage of 3D data lies in its invariance to pose and lighting conditions, which has enhanced recognition systems efficiency. 3D data, however, is somewhat sensitive to changes in facial expressions. This review presents the history of face recognition technology, the current state-of-the-art methodologies, and future directions. We specifically concentrate on the most recent databases, 2D and 3D face recognition methods. Besides, we pay particular attention to deep learning approach as it presents the actuality in this field. Open issues are examined and potential directions for research in facial recognition are proposed in order to provide the reader with a point of reference for topics that deserve consideration.
Face recognition has gained tremendous attention over the last three decades since it is considered a simplified image analysis and pattern recognition application. There are at least two reasons for understanding this trend: (1) the large variety of commercial and legal requests, besides (2) the availability of the relevant technologies (e.g., smartphones, digital cameras, GPU, …). Although the existing machine learning/recognition systems have achieved some degree of maturity, their performance is limited to the conditions imposed in real-world applications [1]. For example, identifying facial images obtained in an unconstrained environment (e.g., changes in lighting, posture, or facial expression, in addition to partial occlusion, disguises, or camera movement) still poses several challenges ahead. In other words, the existing technologies are still far removed from the human visual system capabilities.
In our daily lives, the face is perhaps the most common and familiar biometric feature. With the invention of photography, government departments and private entities have kept facial photographs (from personal identity documents, passports, or membership cards). These collections have been used in forensic investigations, as referential databases, to match and compare a respondent’s facial images (e.g., perpetrator, witness, or victim). Besides, the broad use of digital cameras and smartphones made facial images easy to produce every day; these images can be easily distributed and exchanged by rapidly established social networks such as Facebook and Twitter.

Source:
https://ar5iv.labs.arxiv.org/html/2212.13038
https://www.mdpi.com/2079-9292/9/8/1188

Predictive Text Input
Intelligent text entry systems, including the now-ubiquitous predictive keyboard, can make text entry more efficient, but little is known about how these systems affect the content that people write. To study how predictive text systems affect content, we compared image captions written with different kinds of predictive text suggestions. Our key findings were that captions written with suggestions were shorter and that they included fewer words that that the system did not predict. Suggestions also boosted text entry speed, but with diminishing benefit for faster typists. These findings imply that text entry systems should be evaluated not just by speed and accuracy but also by their effect on the content written.
Predictive text suggestions are ubiquitous on touchscreen keyboards and are growing in popularity on desktop environments as well. For example, suggestions are enabled by default on both Android and iOS smartphones, and the widely used Gmail service offers phrase suggestions on both desktop and mobile. The impacts of system design choices on typing speed, accuracy, and suggestion usage have been studied extensively. However, relatively little is known about how text suggestions affect what people write. Yet suggestions are offered up to several times per second in the middle of an open-ended process of planning the structure and content of writing, so these suggestions have the potential to shape writing content.
Most prior text entry studies have not been able to study the effects of suggestions on content because they either prescribed what text to enter or had no measures that were sensitive to changes in content. The few prior studies that did investigate the content effects of phrase suggestions did not have a no-suggestions baseline, so the effects of single-word suggestions on content are still unknown.
Source:
https://www.eecs.harvard.edu/~kgajos/papers/2020/arnold20predictive.pdf

Voice Assistants
Voice assistants are software programs designed to understand and respond to voice commands, providing users with a hands-free and efficient way to interact with technology. These assistants are powered by artificial intelligence (AI) and natural language processing (NLP) to interpret spoken language and execute tasks or answer questions. They are commonly found in smartphones, smart speakers, computers, and other smart devices.
Some Features of Voice Assistants:
1. Voice Recognition: Voice assistants use advanced algorithms to recognize and understand human speech. This includes interpreting commands, questions, and other vocal inputs in various languages and accents.
2. Natural Language Processing (NLP): NLP allows the voice assistant to understand the meaning of words and sentences, not just the specific words themselves. This makes interactions more conversational.
3. Contextual Awareness: Many voice assistants are capable of recognizing the context in which a question is asked. This helps them provide more accurate and relevant answers based on previous interactions, location, or user preferences.
4. Task Automation: Voice assistants can perform a variety of tasks like setting reminders, making phone calls, sending messages, playing music, adjusting smart home devices, checking the weather, and providing real-time updates (e.g., news, sports scores).
5. Integration with Smart Devices: Many voice assistants are integrated into smart home ecosystems, controlling lights, thermostats, security cameras, and other IoT (Internet of Things) devices.

Source:
https://ieeexplore.ieee.org/document/10690100
https://ieeexplore.ieee.org/document/9210344

What guardrails need to be placed for AI agent to test application, it should not delete unit tests to pass the build.

Mukhtar Wani — Thu, 02 Jul 2026 03:50:12 +0000