## 6 Conclusions  
This paper presents a fault-prone software requirements specification detection model that aims to detect fault-prone software requirements specifications (SRS). The model comprises two parts: the ambiguity classification model (ACM) and the fault-prone software requirements specification detection model (FPDM). The ACM utilizes different deep learning algorithms. Then, the best performance algorithm is selected to classify each software requirement as either ambiguous or clean. The ACM is capable of classifying and detecting the presence of ambiguous requirements in the software requirements specification (SRS), covering a range of ambiguities, including lexical, syntactic, semantic, syntax, and pragmatic ambiguities. The FPDM then uses the key components of SRS--clarity of title and description, presence of intended users, and classified ambiguous requirements--to detect fault-prone SRS. The ACM achieved an accuracy of 0.9907, while the FPDM achieved an accuracy of 0.9750. This study also explored the use of statistical-based features to improve the performance of the FPDM, with a restriction on the number of features to prevent overfitting and maintain accuracy. Subject matter experts were also invited to evaluate the SRS documents for fault-proneness. The implementation of a boosting model was found to enhance the model's accuracy in detecting fault-prone SRS for edge/cloud applications. Developing edge/cloud applications is becoming more challenging due to their distributed nature, heterogeneous networks, and fast-changing market demands. This complexity leads to hastily written and ambiguous software requirements, increasing the fault-proneness of the resulting software. Cloud computing's dynamism and distributed nature further exacerbate these challenges. Considering the distinctive software requirements of edge computing, the SRS plays a critical role in ensuring software systems are developed to meet these demands. Utilizing the FPDM, faults in the SRS were detected and resolved early, enhancing the reliability and quality of the application. In our case study, we developed a fault-prone severity scale to assess the level of ambiguity and potential for errors in the software requirements specification (SRS). To achieve this, we used three formulas, namely the linear mapping function for software requirements, the ambiguity density index (ADI), and the fault-prone SRS score. The utilization of these three formulas allowed us to generate a reliable measure of the severity of faults in the SRS. The continuous advancements in technology and the implementation of boosting algorithms reduced the need for human intervention in the development of predictive models. However, despite the potential of these algorithms to identify and reaffirm the fault-proneness of software requirements specifications (SRS), human intervention is still necessary to interpret the clarity and ambiguity of SRS components. The findings of this study show that boosting algorithms and human expertise improve the accuracy and effectiveness of fault-prone detection models in identifying and distinguishing between ambiguous and clear software requirements and the clarity of other SRS components. Further research is necessary to explore the implementation of boosting algorithms in the development of predictive models to enhance the identification of clean and fault-prone SRS documents. [PERSON] served as the main author and took a leading role in all aspects of the project, including research, development, and analysis, [PERSON] as a co-author significantly contributed by providing numerous ideas and expertise specifically related to fault-prone detection, utilizing boosting techniques consistently throughout the project, [PERSON] provided valuable support in conducting an extensive literature review, ensuring a solid theoretical foundation for the research,R.A.R.